void plateau_modification_deplacer_piece(plateau_siam* plateau,
int x0,int y0,
orientation_deplacement direction_deplacement,
orientation_deplacement orientation_final)
{
assert(plateau_etre_integre(plateau));
assert(coordonnees_etre_dans_plateau(x0, y0));
assert(orientation_etre_integre_deplacement(direction_deplacement));
assert(orientation_etre_integre(orientation_final));
if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
{
piece_definir_case_vide(&plateau->piece[x0][y0]);
}
if(plateau_exister_piece(plateau, x0, y0) && coordonnees_etre_dans_plateau(x0, y0))
{
piece_siam* piece=plateau_obtenir_piece(plateau,x0,y0);
type_piece type=piece->type;
if(plateau_modification_deplacer_piece_etre_possible(plateau,x0,y0,direction_deplacement,orientation_final))
{
int x=x0;
int y=y0;
// on réalise des boucles afin de s'assurer que les coordonnées ne sortiront pas du plateau
if (coordonnees_etre_bordure_plateau(x0, y0)==0)
{
coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
}
else if ( (x0==0 && direction_deplacement!=gauche) || (x0==4 && direction_deplacement!=droite) || (y0==0 && direction_deplacement!=bas) || (y0==4 && direction_deplacement!=haut) )
{
coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
}
else if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
{
piece_definir_case_vide(&plateau->piece[x0][y0]);
plateau->piece[x0][y0].orientation=aucune_orientation;
}
if (piece_etre_case_vide(&plateau->piece[x0][y0]) )
{
if (type!=case_vide)
{piece_definir(&plateau->piece[x0][y0],type,orientation_final);}
}
else
{
poussee_realiser(plateau, x0, y0, plateau->piece[x0][y0].type, direction_deplacement);
}
piece_definir_case_vide(&plateau->piece[x][y]);
}
}
}
void test_api_siam_tenter_deplacer_piece_si_possible()
{
puts("Test api_siam_tenter_deplacer_piece_si_possible");
jeu_siam jeu;
jeu_initialiser(&jeu);
int x=0, y=0;
piece_siam *piece = plateau_obtenir_piece(&(jeu.plateau),x,y);
piece->type=elephant;
piece->orientation=bas;
coup_jeu coup;
coup_jeu_initialiser(&coup);
//on test si le coup est valide en bougeant la bonne piece et avec des coordonnees dans le plateau
coup = api_siam_tenter_deplacer_piece_si_possible(&jeu, x, y, haut, bas);
coordonnees_appliquer_deplacement(&x, &y, haut);
piece_siam *piece_apres_deplacement = plateau_obtenir_piece(&(jeu.plateau),x,y);
if(coup.valide!=1 || piece_apres_deplacement->orientation!= bas || jeu.joueur!=1)
{printf("orientation = %d",piece_apres_deplacement->orientation); puts(" joueur 0/elephant orientation KO");}
//on test si le coup n'est pas valide si on envoie des coordonnees pas dans le plateau
coup = api_siam_tenter_deplacer_piece_si_possible(&jeu, 6, 2, haut, bas);
if(coup.valide!=0 || jeu.joueur!=1)
puts(" joueur 1/coordonnees pas au bord KO");
//on test si le coup est non valide si on essaye de deplacer sur une case avec un animal d'orientation non opposée
int copy_x=x, copy_y=y; //on copie les valeurs de x et y pour introduire une nouvelle piece
coordonnees_appliquer_deplacement(©_x, ©_y, droite); //on change les coordonnes pour introduire la nouvelle piece
//à l'endroit desire
piece_siam *nouvelle_piece = plateau_obtenir_piece(&(jeu.plateau), copy_x, copy_y);
piece_apres_deplacement->type = rhinoceros; //on est au joueur 1 qui joue les rhino, or à la position x et y a il y a un elephant !
nouvelle_piece->type = rhinoceros;
nouvelle_piece->orientation = gauche;
coup = api_siam_tenter_deplacer_piece_si_possible(&jeu, x, y, droite, droite);
if(coup.valide!=0 || jeu.joueur!=1)
puts(" joueur 1/deplacement sur une case avec un animal non oppose KO");
//on test si le coup est valide si on essaye de deplacer sur une case avec un animal d'orientation non opposée
nouvelle_piece->orientation = bas;
coup = api_siam_tenter_deplacer_piece_si_possible(&jeu, x, y, droite, droite);
if(coup.valide!=0 || jeu.joueur!=1)
puts(" joueur 0/deplacement sur une case avec un animal non oppose KO");
}
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 plateau_modification_deplacer_piece_etre_possible(const plateau_siam* plateau,
int x0,int y0,
orientation_deplacement direction_deplacement,
orientation_deplacement orientation)
{
assert(plateau_etre_integre(plateau));
assert(coordonnees_etre_dans_plateau(x0, y0));
assert(orientation_etre_integre_deplacement(direction_deplacement));
assert(orientation_etre_integre(orientation));
if(type_etre_animal(plateau->piece[x0][y0].type))
{
orientation_deplacement orientation_piece_qui_pousse=plateau->piece[x0][y0].orientation;
if ( (x0==0 && direction_deplacement==gauche) || (x0==4 && direction_deplacement==droite) || (y0==0 && direction_deplacement==bas) || (y0==4 && direction_deplacement==haut) )
{
return 1;
}
coordonnees_appliquer_deplacement(&x0,&y0,direction_deplacement);
if( coordonnees_etre_dans_plateau(x0, y0)==0 || poussee_etre_valide(plateau, x0, y0, direction_deplacement ) )
{
if ( piece_etre_case_vide(&plateau->piece[x0][y0])==0 && orientation!=direction_deplacement )
{
puts("orientation finale non valide");
return 0;
}
if(piece_etre_case_vide(&plateau->piece[x0][y0])==0 && orientation_piece_qui_pousse!=direction_deplacement )
{
puts("orientation de la piece qui pousse differente de la direction de deplacement");
return 0;
}
return 1;
}
}
if (poussee_etre_valide(plateau, x0, y0, direction_deplacement)) return 1;
return 0;
}
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;
}
