void plateau_modification_introduire_piece(plateau_siam* plateau,
int x,int y,
type_piece type,
orientation_deplacement orientation)
{
assert(plateau_etre_integre(plateau));
assert(coordonnees_etre_bordure_plateau(x, y));
assert(type_etre_animal(type));
assert(orientation_etre_integre_deplacement(orientation));
if ((plateau_modification_introduire_piece_etre_possible(plateau, x, y, type, orientation)==1))
{
if (piece_etre_case_vide(&plateau->piece[x][y])==1)
{
piece_siam* piece=&plateau->piece[x][y];
piece_definir(piece,type,orientation);
}
else
{
poussee_realiser(plateau, x, y, type, orientation);
piece_definir(&plateau->piece[x][y],type,orientation);
}
}
}
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 plateau_modification_changer_orientation_piece(plateau_siam* plateau,int x0,int y0,orientation_deplacement orientation)
{
assert(plateau_etre_integre(plateau));
assert(plateau_modification_changer_orientation_piece_etre_possible(plateau, x0, y0, orientation)==1);
piece_siam* piece=plateau_obtenir_piece(plateau, x0, y0);
piece->orientation=orientation;
}
int plateau_exister_piece(const plateau_siam* plateau,int x,int y)
{
assert(plateau_etre_integre(plateau)==1);
assert(plateau!=NULL);
assert(coordonnees_etre_dans_plateau(x,y));
const piece_siam* piece=plateau_obtenir_piece_info(plateau,x,y);
assert(piece!=NULL);
if(piece->type == case_vide)
return 0;
else
return 1;
}
int jeu_etre_integre(const jeu_siam* jeu)
{
assert(jeu!=NULL);
//verification du joueur integre
const int joueur=jeu->joueur;
if(joueur_etre_integre(joueur)==0)
return 0;
//verification du plateau integre
const plateau_siam* plateau=&jeu->plateau;
if(plateau_etre_integre(plateau)==0)
return 0;
return 1;
}
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;
}
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;
}
int plateau_modification_introduire_piece_etre_possible(const plateau_siam* plateau,
int x,int y,
type_piece type,
orientation_deplacement orientation)
{
assert(plateau_etre_integre(plateau));
assert(type_etre_animal(type));
assert(orientation_etre_integre_deplacement(orientation));
// cas de l'introduction hors coin quand la piece n'est pas vide
if ( (plateau_exister_piece(plateau, x, y)) && ((x==0 && y>0 && y<4 && orientation!=droite) || (x==4 && y>0 && y<4 && orientation!=gauche) || (y==0 && x>0 && x<4 && orientation!=haut) || (y==4 && x>0 && x<4 && orientation!=bas) ))
{
return 0;
}
// cas de l'introduction dans les coins quand la piece n'est pas vide et que la poussée est valide
if ( (plateau_exister_piece(plateau, x, y)) &&
poussee_etre_valide(plateau, x, y, orientation) && ( ( x==0 && y==0 && (orientation==haut || orientation== droite) ) ||
( x==4 && y==4 && (orientation==bas || orientation== gauche) ) ||
( x==4 && y==0 && (orientation==haut || orientation== gauche) ) ||
( x==0 && y==4 && (orientation==bas || orientation== droite) )
)
)
{
return 1;
}
if( (coordonnees_etre_bordure_plateau(x, y)==1) && poussee_etre_valide(plateau, x, y, orientation) && plateau_denombrer_type(plateau, type)<5 )
{
return 1;
}
else
{
return 0;
}
}
void plateau_initialiser(plateau_siam* plateau)
{
// Initialise l'ensemble des cases du plateau a piece_vide
// sauf les 3 cases du milieu avec un rocher (1,2), (2,2) et (3,2)
//
// L'etat de l'echiquier initial est le suivant:
//
// [4] *** | *** | *** | *** | *** |
// [3] *** | *** | *** | *** | *** |
// [2] *** | RRR | RRR | RRR | *** |
// [1] *** | *** | *** | *** | *** |
// [0] *** | *** | *** | *** | *** |
// [0] [1] [2] [3] [4]
//
int kx=0;
for(kx=0 ; kx<NBR_CASES ; ++kx)
{
int ky=0;
for(ky=0 ; ky<NBR_CASES ; ++ky)
{
piece_siam* piece=plateau_obtenir_piece(plateau,kx,ky);
assert(piece!=NULL);
if(ky==2 && (kx>=1 && kx<=3) )
piece_definir_rocher(piece);
else
piece_definir_case_vide(piece);
}
}
assert(plateau_etre_integre(plateau));
}
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;
}
