int piece_etre_integre(const piece_siam* piece)
{
assert (piece!= NULL); // On verifie que le pointeur est valide
//On verifie que on a des types valides
assert (type_etre_integre (piece -> type) == 1);
assert (orientation_etre_integre (piece -> orientation) == 1);
// Si piece est un animal et possede un deplacement comme orientation
// Il est valide
if(type_etre_animal(piece->type) == 1)
{
if(orientation_etre_integre_deplacement(piece ->orientation) == 1)
return 1;
}
//Si piece n'est pas un animal et aucune deplacement
//Il est valide
else
{
if(orientation_etre_integre_deplacement(piece ->orientation) == 0)
return 1;
}
return 0;
}
condition_victoire_partie verification_condition_victoire_valide(jeu_siam *jeu,int x, int y,orientation_deplacement orientation)
{
assert(jeu!=NULL);
assert(orientation_etre_integre_deplacement(orientation));
assert(coordonnees_etre_dans_plateau(x,y));
condition_victoire_partie condition;
condition_victoire_initialiser(&condition);
type_piece type = piece_etre_derniere_poussee(&(jeu->plateau),x,y,orientation);
if(type==rocher)
{
const piece_siam *piece = premiere_piece_meme_orientation_poussee(&(jeu->plateau),x,y,orientation);
condition.joueur = joueur_obtenir_numero_animal(piece->type);
condition.victoire = 1;
}
return condition;
}
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 mode_interactif_parametres_etre_valides(const jeu_siam* jeu,int x,int y,orientation_deplacement orientation)
{
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
if(coordonnees_etre_dans_plateau(x,y)==0)
{
puts("Coordonnees invalides");
return 0;
}
if(orientation_etre_integre_deplacement(orientation)==0)
{
puts("Orientation invalide");
return 0;
}
return 1;
}
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;
}
}
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
*/
}
coup_jeu api_siam_tenter_introduire_nouvelle_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 (!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 (!coordonnees_etre_bordure_plateau(x, y)) {
// Dans le cas ou la pièce n'est pas introduite sur le bord
// du plateau, le coup n'est pas valide.
puts("\nErreur : Coordonnees hors du bord du plateau");
coup.valide = 0;
return coup;
}
if (!orientation_etre_integre_deplacement(orientation)) {
// L'orientation n'est pas integre, ou est aucune_orientation
// Le coup n'est donc pas valide.
coup.valide = 0;
return coup;
}
type_piece type_joueur_courant = jeu_obtenir_type_animal_courant(jeu);
if (plateau_denombrer_type(&jeu->plateau, type_joueur_courant) >= NBR_ANIMAUX) {
// Déjà trop d'animaux sur le plateau pour le joueur courant
printf("\nErreur : nombre maxmum d'animaux atteins");
coup.valide = 0;
return coup;
}
if (plateau_exister_piece(&jeu->plateau, x, y)) {
int test = 1;
// En x = 0 :
if (x==0) {
// Si (y = 0), 2 orient valides : droite et haut
if (y == 0 && (orientation == bas || orientation == gauche))
test = 0;
else if (y == NBR_CASES && (orientation == haut || orientation == gauche))
test = 0;
// Si y qqconque, 1 orient valide : droite
else if (orientation != droite)
test = 0;
}
// En x = NBR_CASES :
else if (x==NBR_CASES) {
// Si (y = 0), 2 orient valides : droite et haut
if (y == 0 && (orientation == bas || orientation == droite))
test = 0;
else if (y == NBR_CASES && (orientation == haut || orientation == droite))
test = 0;
// Si y qqconque, 1 orient valide : droite
else if (orientation != gauche)
test = 0;
}
if (y==0) {
if (x == 0 && (orientation == bas || orientation == gauche))
test = 0;
else if (x == NBR_CASES && (orientation == bas || orientation == droite))
test = 0;
// Si y qqconque, 1 orient valide : droite
else if (orientation != haut)
test = 0;
}
else if (y==NBR_CASES) {
if (x == 0 && (orientation == haut || orientation == gauche))
test = 0;
else if (x == NBR_CASES && (orientation == haut || orientation == droite))
test = 0;
// Si y qqconque, 1 orient valide : droite
else if (orientation != bas)
test = 0;
}
if (!test) {
puts("\nErreur : Orientation invalide pour pousser");
coup.valide = 0;
return coup;
}
}
if (plateau_modification_introduire_piece_etre_possible(&jeu->plateau, x, y, type_joueur_courant, orientation)) {
plateau_modification_introduire_piece(&jeu->plateau, x, y, type_joueur_courant, 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, y, 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);
}
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 != 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;
}