void test_plateau_obtenir_piece()
{
puts("Test plateau_obtenir_piece");
plateau_siam plateau;
plateau_initialiser(&plateau);
piece_siam *piece = &(plateau.piece[0][0]);
piece->type=elephant;
piece->orientation=haut;
piece = &(plateau.piece[0][1]);
piece->type=rhinoceros;
piece->orientation=haut;
int kx=0;
for(kx=0;kx<NBR_CASES;kx++)
{
int ky=0;
for(ky=0;ky<NBR_CASES;ky++)
{
if(kx == 0 && ky == 0)
{
if(plateau_obtenir_piece(&plateau,kx,ky)->type != elephant)
printf("case [%d][%d] KO\n",kx,ky);
if(plateau_obtenir_piece_info(&plateau,kx,ky)->type != elephant)
printf("case [%d][%d] info KO\n",kx,ky);
}
else if(kx == 0 && ky == 1)
{
if(plateau_obtenir_piece(&plateau,kx,ky)->type != rhinoceros)
printf("case [%d][%d] KO\n",kx,ky);
if(plateau_obtenir_piece_info(&plateau,kx,ky)->type != rhinoceros)
printf("case [%d][%d] info KO\n",kx,ky);
}
else if(ky==2 && (kx>=1 && kx<=3))
{
if(plateau_obtenir_piece(&plateau,kx,ky)->type != rocher)
printf("case [%d][%d] KO\n",kx,ky);
if(plateau_obtenir_piece_info(&plateau,kx,ky)->type != rocher)
printf("case [%d][%d] info KO\n",kx,ky);
}
else
{
if(plateau_obtenir_piece(&plateau,kx,ky)->type != case_vide)
printf("case [%d][%d] KO\n",kx,ky);
if(plateau_obtenir_piece_info(&plateau,kx,ky)->type != case_vide)
printf("case [%d][%d] info KO\n",kx,ky);
}
}
}
}
int plateau_denombrer_type(const plateau_siam* plateau,type_piece type)
{
assert(plateau!=NULL);
// Algorithme:
//
// Initialiser compteur <- 0
// Pour toutes les cases du tableau
//
//Si case courante est du type souhaite
//
//Incremente compteur
// Renvoie compteur
int compteur=0;
int kx=0;
for(kx=0 ; kx<NBR_CASES ; ++kx)
{
int ky = 0;
for(ky=0 ; ky<NBR_CASES ; ++ky)
{
const piece_siam* piece=
plateau_obtenir_piece_info(plateau,kx,ky);
assert(piece!=NULL);
if(piece->type == type)
compteur++;
}
}
return compteur;
}
coup_jeu api_siam_tenter_changer_orientation_piece_si_possible(jeu_siam* jeu,int x,int y,orientation_deplacement orientation)
{
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
coup_jeu coup;
coup_jeu_initialiser(&coup);
if(orientation_etre_integre(orientation)==0){
coup.valide=0;
return coup;
}
// on verifie si on peut changer l'orientation de la piece
if(plateau_modification_changer_orientation_piece_etre_possible(&jeu->plateau,x,y,orientation)==0){
coup.valide=0;
return coup;
}
// on verifie si la piece qu'on veut modifier appartient au joueur courant
if(jeu_verifier_type_piece_a_modifier(jeu,x,y)==0){
coup.valide=0;
return coup;
}
/* si les conditions sont verifies on change l'orientation de la piece,
on change de joueur, on regarde s'il est victorieux et on renvoie le coup valide*/
plateau_modification_changer_orientation_piece(&jeu->plateau,x,y,orientation);
const piece_siam* piece=plateau_obtenir_piece_info(&jeu->plateau,x,y);
assert(piece!=NULL);
assert(piece_etre_integre(piece));//on regarde si on a pas corrompu la piece
jeu_changer_joueur(jeu);
coup.valide=1;
assert(coup_etre_integre(&coup));//on verifie qu'on renvoie un coup integre
return coup;
}
coup_jeu api_siam_tenter_introduire_nouvelle_piece_si_possible(jeu_siam* jeu,
int x,int y,
orientation_deplacement orientation)
{
assert(jeu_etre_integre(jeu));
coup_jeu coup;
coup_jeu_initialiser(&coup);
type_piece type = joueur_obtenir_animal(jeu->joueur);
if(plateau_modification_introduire_piece_etre_possible(&(jeu->plateau),x,y,type,orientation)==0)
return coup;
const piece_siam *piece = plateau_obtenir_piece_info(&(jeu->plateau), x, y);
if(piece->type != case_vide)
{
if(poussee_etre_valide(&(jeu->plateau), x, y, orientation, orientation) == 1)
{
//ici il faut vérifier la condition de victoire avant la poussée
//car si jamais un rocher est au bord, il faut pouvoir le voir avant que la poussé ne soit effectuée !
coup.condition_victoire=verification_condition_victoire_valide(jeu,x,y,orientation);
poussee_realiser(&(jeu->plateau), x, y, orientation, orientation, &(coup.condition_victoire));
}
}
plateau_modification_introduire_piece(&(jeu->plateau),x,y,type,orientation,&(coup.condition_victoire));
coup.valide=1;
//on change de joueur
joueur_changer(&(jeu->joueur));
return coup;
}
int plateau_etre_integre(const plateau_siam* plateau)
{
assert(plateau != NULL);
int compteur_rocher=0;
int compteur_elephant=0;
int compteur_rhinoceros=0;
int kx=0;
for(kx=0;kx<NBR_CASES;++kx)
{
int ky=0;
for(ky=0;ky<NBR_CASES;++ky)
{
const piece_siam* piece =
plateau_obtenir_piece_info(plateau,kx,ky);
assert(piece!=NULL);
if (piece_etre_integre(piece) == 0)
return 0;
switch(piece->type)
{
case rocher :
compteur_rocher++;
break;
case elephant :
compteur_elephant++;
break;
case rhinoceros :
compteur_rhinoceros++;
break;
default :
break;
}
}
}
if(compteur_rocher > NBR_ROCHERS)
return 0;
if( !(compteur_elephant >=0 && compteur_elephant <=NBR_ANIMAUX) )
return 0;
if( !(compteur_rhinoceros >=0 && compteur_rhinoceros <=NBR_ANIMAUX) )
return 0;
return 1;
}
void test_api_siam_tenter_introduire_nouvelle_piece_si_possible()
{
puts("Test api_siam_tenter_introduire_nouvelle_piece_si_possible");
jeu_siam jeu;
jeu_initialiser(&jeu);
coup_jeu coup;
coup_jeu_initialiser(&coup);
const piece_siam *piece = plateau_obtenir_piece_info(&(jeu.plateau),0,0);
//on test si le coup est valide si on envoie des coordonnees au bord
coup = api_siam_tenter_introduire_nouvelle_piece_si_possible(&jeu, 0, 0, haut);
if(coup.valide!=1 || piece->orientation!=haut || jeu.joueur!=1)
puts(" introduction case vide KO");
//on test si le coup n'est pas valide si on envoie des coordonnees pas au bord
coup = api_siam_tenter_introduire_nouvelle_piece_si_possible(&jeu, 1, 1, haut);
if(coup.valide!=0 || jeu.joueur!=1)
puts(" introduction pas au bord KO");
//on test si le coup est valide si on introduit sur une case deja occupee avec une bonne orientation
coup = api_siam_tenter_introduire_nouvelle_piece_si_possible(&jeu, 0, 0, haut);
if(coup.valide!=1 || jeu.joueur!=0)
puts(" introduction sur une piece deja existante bonne orientation KO");
//on test si le coup est non valide si on introduit sur une case deja occupee avec une mauvaise orientation
coup = api_siam_tenter_introduire_nouvelle_piece_si_possible(&jeu, 0, 0, bas);
if(coup.valide!=0 || jeu.joueur!=0)
puts(" introduction sur une piece deja existante mauvaise orientation KO");
//on test si on essaye d'introduire trop de piece (plus de 5)
//il y a déjà un éléphant, il faut en rajouter 4
piece_siam *piece_4_4 = plateau_obtenir_piece(&(jeu.plateau), NBR_CASES-1, NBR_CASES-1);
piece_4_4->type = elephant;
piece_4_4->orientation = gauche;
piece_siam *piece_3_4 = plateau_obtenir_piece(&(jeu.plateau), 3, NBR_CASES-1);
piece_3_4->type = elephant;
piece_3_4->orientation = gauche;
piece_siam *piece_2_4 = plateau_obtenir_piece(&(jeu.plateau), 2, NBR_CASES-1);
piece_2_4->type = elephant;
piece_2_4->orientation = gauche;
piece_siam *piece_1_4 = plateau_obtenir_piece(&(jeu.plateau), 1, NBR_CASES-1);
piece_1_4->type = elephant;
piece_1_4->orientation = gauche;
coup = api_siam_tenter_introduire_nouvelle_piece_si_possible(&jeu, NBR_CASES-1, 0, haut);
if(coup.valide!=0 || jeu.joueur!=0)
puts(" introduction de plus de 5 pieces KO");
}
int plateau_exister_piece(const plateau_siam* plateau,int x,int y)
{
assert(plateau != NULL);
assert(coordonnees_etre_dans_plateau(x,y));
const piece_siam *piece = plateau_obtenir_piece_info(plateau,x,y);
if (piece_etre_case_vide(piece)==1)
return 0;
return 1;
}
const piece_siam *premiere_piece_meme_orientation_poussee(const plateau_siam* plateau, int x, int y,
orientation_deplacement orientation)
{
assert(plateau!=NULL);
assert(orientation_etre_integre_deplacement(orientation));
while(coordonnees_etre_dans_plateau(x,y)==1)
{
coordonnees_appliquer_deplacement(&x,&y,orientation);
}
coordonnees_appliquer_deplacement(&x,&y,orientation_inverser(orientation));
const piece_siam *piece = plateau_obtenir_piece_info(plateau,x,y);
while(piece->orientation != orientation)
{
coordonnees_appliquer_deplacement(&x,&y,orientation_inverser(orientation));
piece = plateau_obtenir_piece_info(plateau,x,y);
}
return piece;
/*Algorithme
on initialise une condition de victoire partie
on cherche le type de la derniere piece de la poussée
Si c'est un rocher (ce qui veut dire que c'est un rocher en bord de plateau,
si c'est un rocher non au bord, alors le type renvoyé est une case vide !!)
on recherche la piece la plus proche du rocher qui a la même orientation que la poussée
on modifie la condition victoire partie initialisée au début pour qu'elle indique le bon joueur gagnant
et qu'il y a un vainqueur
on retourne la condition de victoire
*/
}
int jeu_verifier_type_piece_a_modifier(const jeu_siam* jeu,int x,int y)
{
assert(jeu_etre_integre(jeu));
assert(coordonnees_etre_dans_plateau(x,y));
const piece_siam* piece=plateau_obtenir_piece_info(&jeu->plateau,x,y);
assert(piece!=NULL);
int num_joueur=jeu->joueur;
type_piece type=piece->type;
if (type_etre_animal(type)==0)
return 0;
if(joueur_etre_type_animal(num_joueur,type)==1)
return 1 ;
return 0;
}
int plateau_modification_changer_orientation_piece_etre_possible(const plateau_siam* plateau,int x0,int y0,orientation_deplacement orientation)
{
assert(plateau_etre_integre(plateau));
assert(coordonnees_etre_dans_plateau(x0, y0));
assert(orientation_etre_integre_deplacement(orientation));
const piece_siam* piece=plateau_obtenir_piece_info(plateau, x0, y0);
assert(piece_etre_integre(piece));
if(piece_etre_animal(piece)==1 && piece->orientation!=orientation)
return 1;
if (piece_etre_animal(piece)==1 && piece->orientation==orientation)
return 0;
return 0;
}
void entree_sortie_ecrire_plateau_pointeur_fichier(FILE* identifiant,const plateau_siam* plateau)
{
int y, x;
for (y = NBR_CASES-1; y >= 0; y--) {
fprintf(identifiant, "[%d] ", y);
for (x = 0; x < NBR_CASES; x++) {
const piece_siam *piece = plateau_obtenir_piece_info(plateau, x, y);
if (type_etre_animal(piece->type))
fprintf(identifiant, "%s-%s | ", type_nommer_nom_cours(piece->type), orientation_nommer_nom_cours(piece->orientation));
else
fprintf(identifiant, "%s | ", type_nommer_nom_cours(piece->type));
}
fprintf(identifiant, "\n");
}
fprintf(identifiant, " ");
for (x = 0; x < NBR_CASES; x++) {
fprintf(identifiant, "[%d] ", x);
}
printf("\n");
}
coup_jeu api_siam_tenter_changer_orientation_piece_si_possible(jeu_siam* jeu,int x,int y,orientation_deplacement orientation)
{
assert(jeu_etre_integre(jeu));
coup_jeu coup;
coup_jeu_initialiser(&coup);
if(plateau_modification_changer_orientation_piece_etre_possible(&(jeu->plateau),x,y,orientation)==0)
{
puts(" orientation pas bonne");
return coup;
}
const piece_siam *piece = plateau_obtenir_piece_info(&(jeu->plateau), x, y);
// On vérifie que la pièce au coordonnées indiquées appartienne bien au joueur actuel.
if(piece->type==rocher || piece->type==case_vide)
{
puts(" Vous ne pouvez pas bouger cette pièce (rocher ou case vide) !");
return coup;
}
if(joueur_etre_type_animal(jeu->joueur,piece->type)==0)
{
puts(" La piece choisie n'est pas la votre !");
return coup;
}
plateau_modification_changer_orientation_piece(&(jeu->plateau),x,y,orientation);
coup.valide=1;
//on change de joueur
joueur_changer(&(jeu->joueur));
return coup;
// Cette fonction permet de changer l'orientation d'une pièce, dans tous les cas elle ne permettra pas
// de désigner un vainqueur : on ne changera pas la valeur de coup.victoire (initialisée à 0).
}
int jeu_verifier_type_piece_a_modifier(const jeu_siam* jeu,int x,int y)
{
assert(jeu!=NULL);
assert(coordonnees_etre_dans_plateau(x,y));
//on recupere la piece
const piece_siam* piece= plateau_obtenir_piece_info(&jeu->plateau,x,y);
assert(piece!=NULL);
// on verifie si la piece est un animal
if(piece_etre_animal(piece)==0)
return 0;
// on regarde si la piece est un elephant mais que le joueur est 1
if(piece->type==elephant){
if(jeu->joueur==1)
return 0;
}
//on regarde si la piece est un rhinoceros mais que le joueur est 0
else{
if(jeu->joueur==0)
return 0;
}
//si ce n'etait pas les cas precedents alors on est ok
return 1;
}
coup_jeu api_siam_tenter_deplacer_piece_si_possible(jeu_siam* jeu,
int x,int y,
orientation_deplacement deplacement,
orientation_deplacement orientation)
{
assert(jeu != NULL);
assert(jeu_etre_integre(jeu));
coup_jeu coup;
coup_jeu_initialiser(&coup);
if (!coordonnees_etre_dans_plateau(x, y)) {
// Dans le cas ou les coord ne sont pas de le
// plateau, coup non valide.
puts("\nErreur : Coordonnees hors du plateau");
coup.valide = 0;
return coup;
}
if (!orientation_etre_integre_deplacement(deplacement)) {
// L'orientation de déplacement n'est pas integre, ou est aucune_orientation
// Le coup n'est donc pas valide.
coup.valide = 0;
return coup;
}
if (!orientation_etre_integre_deplacement(orientation)) {
// L'orientation finale n'est pas integre, ou est aucune_orientation
// Le coup n'est donc pas valide.
coup.valide = 0;
return coup;
}
if (!jeu_verifier_type_piece_a_modifier(jeu, x, y)) {
// La piece en question est celle de l'autre joueur
// Le coup n'est pas valide.
puts("\nErreur : Piece non valide pour ce joueur");
coup.valide = 0;
return coup;
}
int x_suivant = x, y_suivant = y;
coordonnees_appliquer_deplacement(&x_suivant, &y_suivant, deplacement);
if (plateau_exister_piece(&jeu->plateau, x_suivant, y_suivant) && deplacement != piece_recuperer_orientation_animal(plateau_obtenir_piece_info(&jeu->plateau, x, y))) {
puts("\nErreur : Orientation invalide pour pousser");
coup.valide = 0;
return coup;
}
if (plateau_modification_deplacer_piece_etre_possible(&jeu->plateau, x, y, deplacement, orientation)) {
plateau_modification_deplacer_piece(&jeu->plateau, x, y, deplacement, orientation);
coup.valide = 1;
if (plateau_denombrer_type(&jeu->plateau, rocher) < NBR_ROCHERS) {
// On a un gagnant !!!
condition_victoire_partie cdt_vic = victoire_determiner_gagnant(&jeu->plateau, x_suivant, y_suivant, orientation);
coup.condition_victoire = cdt_vic;
assert(coup_etre_integre(&coup));
assert(condition_victoire_etre_victorieux(&cdt_vic));
condition_victoire_afficher(&cdt_vic);
}
jeu_changer_joueur(jeu);
}
assert(plateau_etre_integre(&jeu->plateau));
puts("\nERREUR INCONNUE");
return coup;
}
coup_jeu api_siam_tenter_deplacer_piece_si_possible(jeu_siam* jeu,
int x,int y,
orientation_deplacement deplacement,
orientation_deplacement orientation)
{
assert(jeu_etre_integre(jeu));
coup_jeu coup;
coup_jeu_initialiser(&coup);
if(plateau_modification_deplacer_piece_etre_possible(&(jeu->plateau),x,y, deplacement, orientation)==0)
{
puts(" deplacement impossible");
return coup;
}
const piece_siam *piece = plateau_obtenir_piece_info(&(jeu->plateau), x, y);
// On vérifie que la pièce au coordonnées indiquées appartienne bien au joueur actuel.
if(piece->type==rocher || piece->type==case_vide)
{
puts(" Vous ne pouvez pas bouger cette pièce (rocher ou case vide) !");
return coup;
}
if(joueur_etre_type_animal(jeu->joueur,piece->type)==0 )
{
puts(" La piece choisie n'est pas la votre !");
return coup;
}
//on copie les valeurs de x et y pour regarder ensuite à la case après deplacement, pour voir si la poussee
//est réalisable
int x_deplacement = x, y_deplacement=y;
coordonnees_appliquer_deplacement(&x_deplacement, &y_deplacement, deplacement);
//si la piece est au bord et qu'on veut l'enlever (deplacement hors plateau),
//on l'enleve directement et on fini le tour
if(coordonnees_etre_dans_plateau(x_deplacement,y_deplacement) != 1)
{
plateau_modification_deplacer_piece(&(jeu->plateau), x, y , deplacement, orientation, &(coup.condition_victoire));
coup.valide=1;
joueur_changer(&(jeu->joueur));
return coup;
}
piece = plateau_obtenir_piece_info(&(jeu->plateau), x_deplacement, y_deplacement);
if(piece->type != case_vide)
{
if(poussee_etre_valide(&(jeu->plateau), x_deplacement, y_deplacement, deplacement, orientation) == 1)
{
coup.condition_victoire=verification_condition_victoire_valide(jeu,x,y,orientation);
poussee_realiser(&(jeu->plateau), x_deplacement, y_deplacement, deplacement, orientation, &(coup.condition_victoire));
}
else
{
puts(" La poussee n'est pas valide");
return coup;
}
}
plateau_modification_deplacer_piece(&(jeu->plateau), x, y , deplacement, orientation, &(coup.condition_victoire));
coup.valide=1;
//on change de joueur
joueur_changer(&(jeu->joueur));
return coup;
}
