void jeu_changer_joueur(jeu_siam* jeu)
{
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
joueur_changer(&jeu->joueur);
assert(jeu_etre_integre(jeu));
}
void entree_sortie_ecrire_jeu_fichier(const char* filename,const jeu_siam* jeu)
{
assert(filename!=NULL);
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
assert(entree_sortie_fichier_etre_accessible(filename)==1);
// Ouvre fichier
FILE *fid=NULL;
fid=fopen(filename,"w");
assert(fid!=NULL);
if(fid==NULL) //double protection en mode release
{
printf("Erreur ouverture fichier %s\n",filename);
abort();
}
entree_sortie_ecrire_jeu_pointeur_fichier(fid,jeu);
// Ferme fichier
int c=fclose(fid);
if(c!=0) //double protection
{
printf("Erreur fermeture fichier %s\n",filename);
abort();
}
}
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;
}
void mode_interactif_lire_fichier(jeu_siam* jeu,const char* filename)
{
assert(jeu!=NULL);
assert(filename!=NULL);
if(!entree_sortie_fichier_etre_accessible(filename) || !entree_sortie_fichier_exister(filename))
printf("Fichier %s non accessible en lecture\n",filename);
else
{
entree_sortie_lire_jeu_fichier(filename,jeu);
mode_interactif_sauvegarder_jeu_fichier(jeu);
printf(" lit %s\n",filename);
}
assert(jeu_etre_integre(jeu));
}
type_piece jeu_obtenir_type_animal_courant(const jeu_siam* jeu)
{
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
type_piece piece=elephant;// on initialise la piece a renvoyer
// si le joueur est 0 on renvoie son animal l'elephant
if(jeu->joueur==0)
return piece;
// si le joueur est 1 on renvoie sa piece le rhinoceros
if(jeu->joueur==1){
piece=rhinoceros;
return piece;
}
//si on est encore dans cette fonction alors ca a foire
puts("erreur de la fonction jeu_obtenir_type_animal_courant");
exit(EXIT_FAILURE);
return piece;// on doit toujours faire un return a la fin d'une fonction non void
}
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 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;
}
void entree_sortie_lire_jeu_fichier(const char* filename,jeu_siam* jeu)
{
const char *lgn_joueur = "joueur %d";
int joueur;
const char *lgn_int = "[%d]";
const char *lgn_str = "[%s]";
char y_str[10];
char buffer[100];
FILE *identifiant = fopen(filename, "r");
jeu_initialiser(jeu);
if (identifiant == NULL) {
printf("Erreur ouverture fichier %s\n", filename);
exit(1);
}
int y, i;
// 100 : valeur arbitraire, fgets() s'arrete au \n
while (fgets(buffer, 100, identifiant) != 0) {
if (sscanf(buffer, lgn_joueur, &joueur) == 1)
jeu->joueur = joueur;
else if (sscanf(buffer, lgn_int, &y) == 1) {
sscanf(buffer, lgn_str, &y_str);
if (y < 0 || y > NBR_CASES) {
puts("Erreur lecture numero de ligne");
exit(1);
}
for (i = 0; i < NBR_CASES; i++) {
char type_piece_nom_cours[4];
type_piece_nom_cours[0] = buffer[strlen(y_str) + 2 + i*6];
type_piece_nom_cours[1] = buffer[strlen(y_str) + 3 + i*6];
type_piece_nom_cours[2] = buffer[strlen(y_str) + 4 + i*6];
type_piece_nom_cours[3] = '\0';
jeu->plateau.piece[i][y] = piece_correspondre_nom_cours(type_piece_nom_cours);
}
}
}
if (!jeu_etre_integre(jeu)) {
printf("Jeu invalide lecture fichier %s\n", filename);
exit(1);
}
}
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).
}
type_piece jeu_obtenir_type_animal_courant(const jeu_siam* jeu)
{
assert(jeu_etre_integre(jeu));
return joueur_obtenir_animal(jeu->joueur);
}
void mode_interactif_sauvegarder_jeu_fichier(const jeu_siam* jeu)
{
assert(jeu!=NULL);
assert(jeu_etre_integre(jeu));
entree_sortie_ecrire_jeu_fichier("etat_courant.txt",jeu);
}
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;
}
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;
}
