mon code permet de jouer une partie de jeu d'echec simplifié,initialiser cette partie,sauvegarder la partie,charger une autre partie déja joueé,consulter les coups joués de la partie en cours et enfin quitter le jeu en sauvegardant la partie en cours automatiquement.
a faire : amiliorer le look de l'echequier et trouver une partie des regles du FOU (le fou ne doit pas sauter les pièces qui sont dans son traget).
merci
Source / Exemple :
//code fournie a inclure dans un fichier"code_fourni.cpp"
//debut
#include<iostream>
#include<iomanip>
#include<cctype>
#include<cmath>
#include<fstream>
using namespace std;
//Dimension max pour un nom de partie ou de fichier
#define MAX_CAR_NOM 50
//Dimension de l'échiquier (8 x 8)
#define DIM_ECHIQUIER 8
//Enumération définissant les types de pièces
enum type_piece {PION, CAVALIER, FOU, TOUR, DAME, ROI, NB_TYPE_PIECE};
//Énumération définissant les couleurs
//(pour les pièces et les cases)
enum type_couleur {BLANC, NOIR, NB_TYPE_COULEUR};
//Définition d'une case de l'échiquier
struct type_case
{
bool Libre; //Pour savoir si la case est libre
type_couleur CouleurCase; //Couleur de la case
//Les 2 champs ci-dessous seront valides uniquement
//lorsque la case n'est pas libre
type_piece Piece; //Type de pièce dans cette case
type_couleur CouleurPiece; //Couleur de la pièce
};
//Définition d'un coup
struct type_coup
{
//Notation algébrique utilisée pour les 2 champs:
char Src[3]; //Case source
char Dst[3]; //Case destination
};
//Définition d'une entrée pour l'historique
struct type_historique
{
type_coup DernierCoup; //Le dernier coup
type_couleur CouleurDernierCoup; //La couleur ayant joué
type_piece PieceDernierCoup; //La pièce jouée
//Les 2 champs suivant donnent le résultat du coup:
//Pièces de chaque type restantes pour chaque couleur
// unsigned int PiecesRestantes[NB_TYPE_COULEUR][NB_TYPE_PIECE];
//Points restants pour chaque couleur
// unsigned int PointsRestants[NB_TYPE_COULEUR];
};
//Définition d'une partie
struct type_partie
{
char NomPartie[MAX_CAR_NOM] ;//Nom de la partie
bool JeuPret; //Le jeu est-il pret ?
bool JeuFini; //Le jeu est-il fini ?
//Couleur devant jouer ensuite
type_couleur TourAJouer;
//Numéro du prochain coup
unsigned int NumeroCoupAJouer;
//L'échiquier: 8 x 8 cases mais ATTENTION :
//La case [0][0] désigne la case a8
//La case [1][0] désigne la case a7 ...
//La case [7][0] désigne la case a1
type_case Echiquier[DIM_ECHIQUIER][DIM_ECHIQUIER];
};
//prototype de la fonction affectation_remplacer
void affec_remplace( type_partie& , type_coup LeCoup );
//fin du code fournie
/************************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer un coup
paramètres : lecoup(OUT) ------- Enregistrement qui contient le coup saisi par le joueur
unepartie(OUT)----- Enregistrement qui définit les cases source et case destination
unhistorique(OUT)-- Définition d'une entrée pour l'historique
valeur de retour : Valeur booléenne
#include"code_fourni.hpp"//inclusion du fichier contenant les variables
bool jouer (type_coup& lecoup ,type_partie &unepartie,type_historique &unhistorique)
{
bool correct=true; //initialisation de la variable boolèenne
//prototype de la fonction saisi
void saisi(type_coup& , bool& , type_partie , type_historique & );
//prototype de la fonction case_appartenir
void case_appartenir( type_partie, type_coup , bool&);
//prototype de la fonction case_destination
void case_destination(type_partie , type_coup , bool&);
//prototype de la fonction jouer_pion
void jouer_pion(type_partie& ,type_coup , bool&);
//prototype de la fonction jouer_tour
void jouer_tour(type_partie& ,type_coup , bool&);
//prototype de la fonction jouer_cavalier
void jouer_cavalier(type_partie& ,type_coup , bool&);
//prototype de la fonction jouer_fou
void jouer_fou(type_partie& ,type_coup , bool&);
//prototype de la fonction jouer_roi
void jouer_roi(type_partie& ,type_coup , bool& );
saisi(lecoup , correct , unepartie , unhistorique);//appel de la fonction saisi
if(correct) //si la saisi est correcte
{
case_appartenir(unepartie , lecoup , correct);//appel de la fonction case_appartenir
case_destination(unepartie , lecoup , correct);//appel de la fonction case_destination
switch(unepartie.Echiquier[lecoup.Src[1]-'1'][tolower(lecoup.Src[0])-'a'].Piece)
{ //l'appel des fonction se fait selon le type de la pièce,
case PION : jouer_pion(unepartie ,lecoup , correct) ;break;
case TOUR : jouer_tour(unepartie ,lecoup , correct) ;break;
case CAVALIER : jouer_cavalier(unepartie , lecoup , correct) ;break;
case FOU : jouer_fou(unepartie , lecoup , correct ) ;break;
case DAME : //combinaison entre fonction fou et tour
{
if((lecoup.Src[0]==lecoup.Dst[0]) || (lecoup.Src[1]==lecoup.Dst[1]))
jouer_tour(unepartie ,lecoup , correct);
else
jouer_fou(unepartie , lecoup , correct );
break;
}
case ROI : jouer_roi(unepartie, lecoup , correct) ;break;
}
}
return(correct);//la reponse de la fonction jouer,si correct continuer si non un message
//d'erreur approprié s'affiche à l'ècran
}
/*************************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction initialiser l'echiquier
place toutes les pièces à leurs positions initiales
paramètres : unepartie(OUT)----- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void ini_echiquier(type_partie &partie)
{
char nom_partie[MAX_CAR_NOM] = "\0";
ofstream fichier;
char ligne,colonne;
int carre;
char NomFichier[50];
int bit;
partie.NumeroCoupAJouer=0;
//prototype de la fonction afficher l'echiquier
void aff_echiquier (type_partie );
// initialisation de chaque case d'echiquier
for(ligne=7;ligne>=0;ligne--)
{
for(colonne='a';colonne<='h';colonne++)
{
carre=(colonne -'a')+(ligne)*8;
if(carre>=0 && carre<=63)//imposer juste la couleur des cases
{
partie.Echiquier[ligne][colonne-'a'].Libre=1;
if(ligne==0 || ligne==2||ligne==4 || ligne==6){bit=1;}
if(ligne==1||ligne==3||ligne==5||ligne==7){bit=0;}
if(carre%2==bit)
partie.Echiquier[ligne][colonne-'a'].CouleurCase=BLANC;
else
partie.Echiquier[ligne][colonne-'a'].CouleurCase=NOIR;
}//imposer pour chaque case restante une pièce
if(carre==56||carre==63)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=TOUR;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
partie.Echiquier[ligne][0].CouleurCase=BLANC;
partie.Echiquier[ligne][7].CouleurCase=NOIR;
}
if(carre==57||carre==62)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=CAVALIER;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
partie.Echiquier[ligne][6].CouleurCase=BLANC;
partie.Echiquier[ligne][1].CouleurCase=NOIR;
}
if(carre==58||carre==61)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=FOU;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
partie.Echiquier[ligne][2].CouleurCase=BLANC;
partie.Echiquier[ligne][5].CouleurCase=NOIR;
}
if(carre==59)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=DAME;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
partie.Echiquier[ligne][3].CouleurCase=NOIR;
}
if(carre==60)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=ROI;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
partie.Echiquier[ligne][4].CouleurCase=BLANC;
}
if(carre==0||carre==7)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=TOUR;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
partie.Echiquier[ligne][0].CouleurCase=NOIR;
partie.Echiquier[ligne][7].CouleurCase=BLANC;
}
if(carre==1||carre==6)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=CAVALIER;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
partie.Echiquier[ligne][6].CouleurCase=NOIR;
partie.Echiquier[ligne][1].CouleurCase=BLANC;
}
if(carre==2||carre==5)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=FOU;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
partie.Echiquier[ligne][2].CouleurCase=NOIR;
partie.Echiquier[ligne][5].CouleurCase=BLANC;
}
if(carre==3)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=DAME;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
partie.Echiquier[ligne][3].CouleurCase=BLANC;
}
if(carre==4)
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=ROI;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
partie.Echiquier[ligne][4].CouleurCase=NOIR;
}
if(carre>=48&&carre<=55)//les huit pions noir
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=PION;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=NOIR;
}
if(carre>=8&&carre<=15)//les huit pions blanc
{
partie.Echiquier[ligne][colonne-'a'].Libre=0;
partie.Echiquier[ligne][colonne-'a'].Piece=PION;
partie.Echiquier[ligne][colonne-'a'].CouleurPiece=BLANC;
}
}
}
aff_echiquier (partie);
cout <<"\n* Donner un nom a votre parite d'echec :";
cin >> nom_partie;
strcpy(NomFichier, nom_partie);//affecter le nom de la partie a une variable
strcat(NomFichier, ".hst"); //pour qu'il reste intact
fichier.open(NomFichier, ios::binary| ios::out );//ouverture du fichier historique
if(fichier.fail())//test d'ouverture du fichier
cout<<"* Probleme d'ouverture du fichier:"<<NomFichier<<endl;
else
cout<<setw(40)<<"\n"<<char (1)<<" la partie "<< NomFichier <<" est initialisee,a vous "<<char (1)<<"\n\n";
partie.TourAJouer=BLANC; //selon la couleur du joueur,
cout<<"prochain coup("<<partie.NumeroCoupAJouer<<"): "<<"BLANC"<<"\n\n";//la partie est prete
strcpy(partie.NomPartie, nom_partie);//affecter le nom du partie à variable globale
partie.JeuPret = 0;//initialisé les deux variables
partie.JeuFini= 0;
partie.NumeroCoupAJouer=0;
fichier.close();
cout<<endl;
}
/*************************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction saisi
permet de tester si la saisie est valide ou non
les cases source et destination doivent exsiter
paramètres : lecoup(OUT) ------- Enregistrement qui contient le coup saisi par le joueur
saisi(OUT)--------- variable globale pour la fonction jouer un coup
partie-------- Enregistrement qui définit les cases source et case destination
unhistorique(OUT)-- Définition d'une entrée pour l'historique
valeur de retour : aucune
void saisi(type_coup& un_coup , bool& saisi , type_partie partie , type_historique & Unhistorique )
{
char s,d;
saisi=true;
cout<<"Donner un coup (sourcedestination): ";
cin.get(un_coup.Src,3);//lire la case source
cin.get(un_coup.Dst,3);//lire la case destination
s=tolower(un_coup.Src[0]);
d=tolower(un_coup.Dst[0]);
//test si la saisi est correcte
if ( (s<'a') || (s>'h') || (un_coup.Src[1]<'1') || (un_coup.Src[1]>'8') )
{saisi = false; cout<<" Verifie case source!\n";}
if ( (d<'a') || (d>'h') || (un_coup.Dst[1]<'1') || (un_coup.Dst[1]>'8'))
{saisi = false; cout<<" Verifie case destination !\n";}
//affecter la saisi aux variables historiques
strcpy(Unhistorique.DernierCoup.Src,un_coup.Src);
strcpy(Unhistorique.DernierCoup.Dst,un_coup.Dst);
Unhistorique.CouleurDernierCoup =
partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].CouleurPiece;
Unhistorique.PieceDernierCoup =
partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].Piece;
}
/************************************************************************************************
description : fonction case_appartenir
la piece source doit appartenir au joueur
paraètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void case_appartenir(type_partie partie , type_coup un_coup , bool& correct )
{
// verification que la case source ne contient aucune pieces libre
if (partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].Libre==1 )
{
cout<<" la case source ne contient aucune piece!";
correct=false;
}
else
{ // test si la pièce source appartient au joueur qui veux jouer
if(partie.TourAJouer == BLANC)
{
if(partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].CouleurPiece ==NOIR)
{
cout<<" la piece source n a pas la meme couleur que la votre(blanc)"<<endl;
correct=false;
}
}
else
{
if(partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].CouleurPiece ==BLANC)
{
cout<<" la piece source n a pas la meme couleur que la votre(noir)"<<endl;
correct=false;
}
}
}
}
/***********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction case_destination
la case destination ne doit pas etre occupee par une piece du meme joueur
paraètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void case_destination(type_partie partie , type_coup un_coup , bool& correct)
{ //la case destination ne doit pas contenir une pièce du meme joueur
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre == 0)//case dst
{ //est occupée
if(partie.TourAJouer == BLANC)//selon la couleur
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].CouleurPiece == BLANC)
{
cout<<" la piece destination a la meme couleur que la votre(blanc)"<<endl;
correct=false;
}
}
else
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].CouleurPiece == NOIR)
{
cout<<" la piece destination a la meme couleur que la votre(noir)"<<endl;
correct=false;
}
}
}
}
/***********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDGA KADJO Julien
description : fonction affectation de la case source a la case destination
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void affec_remplace( type_partie &partie, type_coup un_coup)
{
// affecter la source a la destination en changeant les variables relatives à la case
partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre=0;
partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].Libre=1;
partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Piece =
partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].Piece;
partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].CouleurPiece =
partie.Echiquier[un_coup.Src[1]-'1'][tolower(un_coup.Src[0])-'a'].CouleurPiece;
}
/************************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer_pion
la piece jouée doit respecter les regles de deplacement
la fonction appel la fonction affecter
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void jouer_pion(type_partie &partie,type_coup un_coup , bool& correct)
{
int carre_scr,carre_dst,diff_carre;
char i,a,b,c,d;
//calcul des numèros identifiants chaque case de l'echiquier
carre_scr= ( tolower(un_coup.Src[0]) -'a')+((un_coup.Src[1]-'1')*8); // carre_scr
carre_dst= ( tolower(un_coup.Dst[0]) -'a')+((un_coup.Dst[1]-'1')*8); // carre_dst
diff_carre = abs(carre_scr - carre_dst);
if(partie.TourAJouer==BLANC)//le retour des pion n'est pas permis
{ //le test se fait selon la couleur
if(un_coup.Dst[1]<un_coup.Src[1])
{
cout<<"retour du pion non permis"<<endl;
correct=false;
}
}
else
{
if(un_coup.Dst[1]>un_coup.Src[1])
{
cout<<"retour du pion non permis"<<endl;
correct=false;
}
}
// test un saut d'une piece
if(tolower(un_coup.Src[0])==tolower(un_coup.Dst[0]))
{
b=un_coup.Dst[1]-'1';
a=un_coup.Src[1]-'1';
if(a>b) { c=a;d=b;}// d = petit c = grand
else { c=b;d=a;}
for(i=d+1 ; i<c ; i++)//pour toutes les cases entre source et destination
{ // faire le test si libre ou non
if (correct==true && partie.Echiquier[i][tolower(un_coup.Dst[0])-'a'].Libre==0 )
{
cout<<" Saut d une piece!"<<endl;
correct=false;
}
}
}// fin test saut piece
// test pour un deplacement
if(correct==true)
{
if ((diff_carre)==16 || (diff_carre)==8 )//si le pion se déplace de 2 ou 1 case
{
if((diff_carre)==16 )//test pour que le pion ne se deplace(Par 2 case) pas
{ //plus qu.une fois
if(partie.TourAJouer==BLANC)
{
if(carre_scr>15)//régle de cette déplacement pour les blanches
{
cout<<"deplacement incorrect;seulement pour la 1 ere fois"<<endl;
correct=false;
}
}
else
{
if(carre_scr<48)//régle de cette déplacement pour les noirs
{
cout<<"deplacement incorrect;seulement pour la 1 ere fois"<<endl;
correct=false;
}
}
}
//si destination est libre
if(correct==true)
{
if (partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==1)
{
// appel de la fonction d affectation et de remplacement
affec_remplace( partie,un_coup);
}
else
{ //si destination est full
cout<<" deplacement incorrect!"<<endl;
correct=false;
}
}
}
else
if (!((diff_carre)==9 || (diff_carre)==7))//si deplacement sous forme capture
{
cout<<" deplacement incorrect!"<<endl;
correct=false;
}
}// fin test deplacement
//test pour une capture
if ((diff_carre)==9 || (diff_carre)==7)//régle du capture
{ //si destination est full
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==0)
{ //si destination est roi
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0]) -'a'].Piece==ROI)
{
partie.JeuFini=1; //changer l'état de la variable
cout<<" la partie est fini"<<endl;//annonce la fin de la partie
affec_remplace( partie, un_coup); //apple de la fonction affecter remplacer
}
else
affec_remplace( partie, un_coup); //apple de la fonction affecter
}
else // si destination est libre
{
cout<<" la case destination ne contient aucune piece!"<<endl;
correct=false;
}
}
else
{
if (!((diff_carre)==16 || (diff_carre)==8) ) //si capture sous forme deplacement
{
cout<<" capture incorrect!"<<endl;
correct=false;
}
}// fin test capture
}
/*********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer_tour
la piece jouée doit respecter les regles de deplacement
la fonction appel la fonction affecter
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void jouer_tour(type_partie &partie, type_coup un_coup , bool& correct)
{
//declaration des variables
int diff_ligne;//pour calculer la différence entre ligne source et destination
int diff_colonne;//pour calculer la différence entre colonne source et destination
int diff_carre,carre_scr,carre_dst;//pour calculer diff carrés
char i,j,a,b,c,d;
diff_ligne=abs((un_coup.Dst[1]-'1')-(un_coup.Src[1]-'1'));
diff_colonne=abs(tolower(un_coup.Dst[0]-'a')-tolower(un_coup.Src[0]-'a'));
carre_scr=( tolower(un_coup.Src[0]) -'a')+((un_coup.Src[1]-'1')*8); // carre_scr
carre_dst=( tolower(un_coup.Dst[0]) -'a')+((un_coup.Dst[1]-'1')*8); // carre_dst
diff_carre=abs(carre_dst- carre_scr);
// si le déplacement est diagonal
if((!(diff_carre==diff_colonne))&&((!(diff_carre/8)==diff_ligne)))
{
cout<<" le deplacement diagonal est incorrect"<<endl;
correct=false;
}
//déplacement sur la meme colonne
if(tolower(un_coup.Src[0])==tolower(un_coup.Dst[0]))
{ //pour tester le saut de la tour
b=un_coup.Dst[1]-'1';
a=un_coup.Src[1]-'1' ;
if(a>b) { c=a;d=b;}// d = petit c = grand
else { c=b;d=a;}
for(i=d+1 ; i<c ; i++)//pour toutes les cases entre source et destination
{
if (correct==true && partie.Echiquier[i][tolower(un_coup.Dst[0])-'a'].Libre==0 )
{
cout<<" Saut d une piece!"<<endl;
correct=false;
}
}
}
else
{ //déplacement sur la meme ligne
if(un_coup.Src[1]==un_coup.Dst[1])
{ //pour tester le saut de la tour
a=tolower (un_coup.Src[0]-'a');
b=tolower (un_coup.Dst[0]-'a');
cout<<"a="<<a<<" b="<<b<<endl;
if(a>b) { c=a;d=b;}
else { c=b;d=a;} //d=petit et c=grand
for(j=d+1 ; j<c ; j++)//pour toutes les cases entre source et destination
{
if (correct==true && partie.Echiquier[un_coup.Src[1]-'1'][j].Libre==0)
{
cout<<" Saut d une piece!"<<endl;
correct=false;
}
}
}
}
if(correct==true)//test du capture
{ //si la case destination est full
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==0)
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0]) -'a'].Piece==ROI)
{
partie.JeuFini=1;
cout<<" la partie est fini"<<endl;
affec_remplace( partie,un_coup); //apple de la fonction affecter remplacer
}
else
affec_remplace( partie, un_coup); //apple de la fonction affecter
}
else
affec_remplace( partie, un_coup);
}
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer_cavalier
la piece jouée doit respecter les regles de deplacement
la fonction appel la fonction affecter
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void jouer_cavalier(type_partie &partie,type_coup un_coup , bool& correct)
{
int diff_carre,carre_scr,carre_dst;
carre_scr=( tolower(un_coup.Src[0]) -'a')+((un_coup.Src[1]-'1')*8); // carre_scr
carre_dst=( tolower(un_coup.Dst[0]) -'a')+((un_coup.Dst[1]-'1')*8); // carre_dst
diff_carre=abs(carre_dst- carre_scr);
//si contre les régle du déplacement du cavalier
if(!(diff_carre==10 || diff_carre==6|| diff_carre==17 || diff_carre==15))
{
cout<<" le deplacement est incorrect";
correct=false;
}
else //si la meme chose que les régles
{ //verifier
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==0)
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0]) -'a'].Piece==ROI)
{
partie.JeuFini=1;
cout<<" la partie est fini"<<endl;
affec_remplace( partie, un_coup); //apple de la fonction affecter remplacer
}
else
affec_remplace( partie, un_coup); //apple de la fonction affecter
}
else
affec_remplace( partie, un_coup);
}
}
/*********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer_fou
la piece jouée doit respecter les regles de deplacement
la fonction appel la fonction affecter
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
/**********************************************************************************************/
void jouer_fou(type_partie &partie, type_coup un_coup , bool& correct)
{
//declaration des variables
float diff_carre,diff_ligne,carre_scr,carre_dst;
int i;
carre_scr=( tolower(un_coup.Src[0]) -'a')+((un_coup.Src[1]-'1')*8); // carre_scr
carre_dst=( tolower(un_coup.Dst[0]) -'a')+((un_coup.Dst[1]-'1')*8); // carre_dst
diff_carre=abs(carre_dst- carre_scr);
diff_ligne=abs((un_coup.Dst[1]-'1')-(un_coup.Src[1]-'1'));
//contre les regles du déplacement
if(!( ((diff_carre/9)==diff_ligne) || ((diff_carre/7)==diff_ligne) ))
{
cout<<" le deplacement est incorrect";
correct=false;
}//si les regles sont respectées
else
{
//saut d une piece
for(i=1 ; i<diff_ligne ; i++)//pour toutes les cases entres source et destination
{
if(un_coup.Dst[1]>un_coup.Src[1])
{
if(partie.Echiquier[(un_coup.Src[1]-'1')+i][tolower((un_coup.Src[0])-'a')+i].Libre==0)
{
correct=false;
cout<<" saut de piece"<<endl;
}
}
else
{
if(partie.Echiquier[(un_coup.Src[1]-'1')-i][tolower((un_coup.Src[0])-'a')-i].Libre==0)
{
correct=false;
cout<<" saut de piece"<<endl;
}
}
}
//capture et deplacement
if(correct==true)
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==0)
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0]) -'a'].Piece==ROI)
{
partie.JeuFini=1;
cout<<" la partie est fini"<<endl;
affec_remplace( partie, un_coup); //apple de la fonction affecter remplacer
}
else
affec_remplace( partie, un_coup); //apple de la fonction affecter
}
else
affec_remplace( partie, un_coup);
}
}
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction jouer_roi
la piece jouée doit respecter les regles de deplacement
la fonction appel la fonction affecter
paramètres : lecoup--- Enregistrement qui contient le coup saisi par le joueur
correct(OUT)-- variable globale pour la fonction jouer un coup
partie(OUT)--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
/**********************************************************************************************/
void jouer_roi(type_partie &partie, type_coup un_coup , bool& correct)
{
int diff_carre,carre_scr,carre_dst;
carre_scr=( tolower(un_coup.Src[0]) -'a')+((un_coup.Src[1]-'1')*8); // carre_scr
carre_dst=( tolower(un_coup.Dst[0]) -'a')+((un_coup.Dst[1]-'1')*8); // carre_dst
diff_carre=abs(carre_dst- carre_scr);
//contre les régles du déplacement du roi
if(!(diff_carre==7 || diff_carre==8 || diff_carre==9 || diff_carre==1))
{
cout<<" le deplacement est incorrect";
correct=false;
}
else //si les régles sont respecteés
{ //si la case destination est full
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0])-'a'].Libre==0)
{
if(partie.Echiquier[un_coup.Dst[1]-'1'][tolower(un_coup.Dst[0]) -'a'].Piece==ROI)
{
partie.JeuFini=1;
cout<<" la partie est fini"<<endl;
affec_remplace( partie, un_coup); //apple de la fonction affecter remplacer
}
else
affec_remplace( partie, un_coup); //apple de la fonction affecter
}
else
affec_remplace( partie, un_coup);
}
}
/*********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction afficher l'echiquier
paramètres : partie--- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune
void aff_echiquier (type_partie partie)
{
typedef char type_echiquier_char[8][8];
type_echiquier_char echiquier;
char tab_piece_blanc[NB_TYPE_PIECE]={'P','C','F','T','D','R'};
char tab_piece_noir[NB_TYPE_PIECE]={'p','c','f','t','d','r'};
cout<<endl;
for(int ligne=7;ligne>=0;ligne--)
{
cout<<int(ligne+1)<<' ';
for(int colonne='a';colonne<='h';colonne++)
{
if( partie.Echiquier[ligne][colonne - 'a'].Libre ==0 )//si la case est full
{
if( partie.Echiquier[ligne][colonne - 'a'].CouleurPiece == 0 )//si la pièce
{ //est blanche
echiquier[ligne][colonne - 'a'] = //recoit une lette du tableau maj
tab_piece_blanc[partie.Echiquier[ligne][colonne - 'a'].Piece];
}
if(partie.Echiquier[ligne][colonne - 'a'].CouleurPiece == 1 )//si la pièce
{ //est noir
echiquier[ligne][colonne - 'a'] =//recoit une lette du tableau muniscule
tab_piece_noir[partie.Echiquier[ligne][colonne - 'a'].Piece];
}
}
else
{
if(partie.Echiquier[ligne][colonne - 'a'].CouleurCase == 0)//si couleur
echiquier[ligne][colonne - 'a'] =char (219); //case est blanche
else
echiquier[ligne][colonne - 'a'] =' ';//si couleur case est noir
}
cout<<echiquier[ligne][colonne - 'a'];//affichage de l'echiquier
}
cout<<endl;
}
cout<<" abcdefgh"<<"\n\n";
}
/********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
Description : Fonction pour sauvegarder le dernier coup jouer
paramètres : NomPartie----- contient le nom de la partie
unhistorique(OUT)-- Définition d'une entrée pour l'historique
retourne : aucune valeur
void SauverDernierCoupHistorique(const char NomPartie[] , type_historique &Unhistorique)
{
fstream fichier;//pour acceder au fichier historique
char NomFichier[50]; //variable intermidiaire
strcpy(NomFichier, NomPartie);
strcat(NomFichier, ".hst");
fichier.open(NomFichier, ios::binary | ios::out |ios::in );
if (fichier.is_open())//test d'ouverture du fichier
{
fichier.seekg(0, ios::end);//se positionner à la fin du fichier
fichier.write((char*)&Unhistorique,sizeof(type_historique));//ecriture ds le fichier
}
else
{
cout<<" probleme d'ouverture du fichier "<<NomFichier<<" pour sauver un coup pour l historique!\n";
}
fichier.close();
}
/********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
Description : Fonction pour afficher un intervalle de coups d'historique
paramètres : NomPartie----- contient le nom de la partie
unhistorique(OUT)-- Définition d'une entrée pour l'historique
retourne : aucune valeur
void AfficherCoupHistorique( const char NomPartie[], type_historique & Unhistorique)
{
int nbr_coup,pos;
int dep,fin,i;
fstream fichier;
char NomFichier[50];
char tab_couleur[NB_TYPE_COULEUR][6]={"BLANC","NOIR"};//initialisation des tableaux
char tab_piece[NB_TYPE_PIECE][10]={"PION", "CAVALIER", "FOU", "TOUR", "DAME", "ROI"};
strcpy(NomFichier, NomPartie);
strcat(NomFichier, ".hst");
fichier.open(NomFichier,ios::binary | ios::out | ios::in );
if (!( fichier.fail() && fichier.eof() ) )//tant que l'ouverture est correcte
{ // et non end of file
fichier.seekg(0,ios::end);
nbr_coup = fichier.tellg()/sizeof(type_historique);//calcul du nbr des coups
cout<<"Le nombre d element dans le fichier " << NomPartie << " est :"<<nbr_coup<<endl;
cout<<"***Donner l intervalle des Numeros des coups a afficher*** \n"
<<"Depart (max "<<nbr_coup<<") :";//saisi de l'intervalle voulue
cin>>dep;
cout<<"Fin (max "<<nbr_coup<<") :";
cin>>fin;
if(fin<=nbr_coup)//test du saisi
{
fichier.seekg((dep-1)*sizeof(type_historique),ios::beg);//se positionner à (dep-1)
pos=fichier.tellg()/sizeof(type_historique);//donner la position actuelle
fichier.read((char*)&Unhistorique,sizeof(type_historique));//lecture du fichier
for(i=pos-1;i<=((pos-1)+(fin - dep));i++)//parcourir l'intervalle
{
cout<<"coup "<<i+2<< "( ";
fichier.read((char*)&Unhistorique,sizeof(type_historique));
if(Unhistorique.CouleurDernierCoup==0)//test du couleur de la pièce
{
cout<<tab_couleur[0]<<"):";//blanche
}
else
{
cout<<tab_couleur[1]<<" ):";//noir
}
switch(Unhistorique.PieceDernierCoup)//selon le type de la pièce
{
case 00 :cout<<"PION ";
break;
case 01 :cout<<"CAVALIER ";
break;
case 02 :cout<<"FOU ";
break;
case 03 :cout<<"TOUR ";
break;
case 04 :cout<<"DAME ";
break;
case 05 :cout<<"ROI ";
break;
}
cout<<Unhistorique.DernierCoup.Src //affichage du coup
<<" "<<Unhistorique.DernierCoup.Dst<<endl;
}
}
else
cout<<"L intervalle donner est incorrect !\n";
}
else
{
cout<<"probleme d'ouverture du fichier("<<NomFichier<<")pour consulter l historique!";
}
fichier.clear();
fichier.close();
}
/*************************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : jouer prochain coup
permet de jouer un coup et fait apple à la fonction de sauvegarde
paramètres : lecoup ------- Enregistrement qui contient le coup saisi par le joueur
unepartie(OUT)----- Enregistrement qui définit les cases source et case destination
unhistorique(OUT)-- Définition d'une entrée pour l'historique
valeur de retour : aucune valeur
void jouer_prochain(type_partie &unepartie,type_historique & unhistorique)
{
type_coup un_coup;
//prototype de la fonction jouer
bool jouer (type_coup&,type_partie &,type_historique &);
//SauverDernierCoupHistorique( unepartie, Unhistorique);
void SauverDernierCoupHistorique( const char NomPartie[] , type_historique &);
//appel de la fonction jouer et afficher
if( jouer (un_coup,unepartie,unhistorique))//si le coup est valide
{
unepartie.NumeroCoupAJouer++;//incrémenter le numero du coup
SauverDernierCoupHistorique( unepartie.NomPartie, unhistorique);//appel de la fonction
if(unepartie.TourAJouer == BLANC) //du save coup histo
unepartie.TourAJouer = NOIR;//changer le tour du joueur
else
unepartie.TourAJouer = BLANC;
}
}
/***********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : charger une partie
permet de charger une partie d'echèc déja jouée
paramètres : NomPartie-- contient le nom de la partie
partie(OUT)----- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune valeur
void charger_partie(type_partie &partie)
{
char col;//declaration des variables
int lig;
char colonne;
char NomFichier[50];//varable intermidiaire
char tourajouer [5];//varable intermidiaire
char CouleurPiece[5];//varable intermidiaire
char Piece[10];//varable intermidiaire
int ligne;
int carre;
int bit;
int etatpartie;//varable intermidiaire
ifstream fic_in;//pour lire le fichier texte
partie.JeuPret = 0;//initialisé les deux variables
partie.JeuFini= 0;
cout << "\n* Donner le nom de la partie a charger : ";
cin >> partie.NomPartie;
strcpy(NomFichier, partie.NomPartie);
strcat(NomFichier, ".txt");
fic_in.open(NomFichier,ios::in);//ouverture du fichier
if(fic_in.fail())
cout << " La partie a telecharger n exsite pas !" << endl;
else
{
for(ligne=7;ligne>=0;ligne--)//juste pour donner les couleures des cases
{
for(colonne='a';colonne<='h';colonne++)
{
carre=(colonne -'a')+(ligne)*8;
if(carre>=0 && carre<=63)
{
if(ligne==0 || ligne==2||ligne==4 || ligne==6){bit=1;}
if(ligne==1||ligne==3||ligne==5||ligne==7){bit=0;}
if(carre%2==bit)
{
partie.Echiquier[ligne][colonne-'a'].Libre=1;
partie.Echiquier[ligne][colonne-'a'].CouleurCase=BLANC;
}
else
{
partie.Echiquier[ligne][colonne-'a'].Libre=1;
partie.Echiquier[ligne][colonne-'a'].CouleurCase=NOIR;
}
}
}
}
fic_in >> partie.NumeroCoupAJouer >>etatpartie >> tourajouer;//lire la 1ere ligne du fichier
if(etatpartie==0) //selon l'etat de la partie
partie.JeuPret=0;
else
partie.JeuFini=1;
if(!strcmp(tourajouer, "BLANC"))//selon la couleur du tour a jouer
partie.TourAJouer = BLANC;
else
partie.TourAJouer = NOIR;
cout<<"* Nombre des coups : "<<partie.NumeroCoupAJouer<<endl;
if(etatpartie==0)
cout<<"* Etat partie : continuer a jouer" << endl;
else
cout<<"* Etat partie : la partie est fini" << endl;
cout<<"* A toi : "<<tourajouer<<"\n\n";
while(!fic_in.eof())
{
//lecture du reste du fichier
fic_in >> col >> lig;
fic_in >> Piece;
fic_in >> CouleurPiece;
partie.Echiquier[lig-1][col - 'a'].Libre = 0;
if(!strcmp(Piece, "PION"))//affectation aux cases de l'echiquier le type de la pièce
partie.Echiquier[lig-1][col - 'a'].Piece =PION ;
else if(!strcmp(Piece, "CAVALIER"))
partie.Echiquier[lig-1][col - 'a'].Piece =CAVALIER ;
else if(!strcmp(Piece, "FOU"))
partie.Echiquier[lig-1][col - 'a'].Piece =FOU ;
else if(!strcmp(Piece, "TOUR"))
partie.Echiquier[lig-1][col - 'a'].Piece =TOUR;
else if(!strcmp(Piece, "DAME"))
partie.Echiquier[lig-1][col - 'a'].Piece =DAME;
else if (!strcmp(Piece, "ROI"))
partie.Echiquier[lig-1][col - 'a'].Piece =ROI ;
if(!strcmp(CouleurPiece, "BLANC"))//affectation aux case la couleur de la piece
partie.Echiquier[lig-1][col - 'a'].CouleurPiece=BLANC;
else
partie.Echiquier[lig-1][col - 'a'].CouleurPiece=NOIR;
}
aff_echiquier (partie);//appel de la fonction afficher echiquier
cout<<char (1)<<" succes de l operation du chargement de la partie "<<NomFichier<<" "<<char(1)<<"\n";
}
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDJA KADJO Julien
description : fonction Nomligne une partie
permet de sauvegarder une partie d'echèc
paramètres : NomPartie-- contient le nom de la partie
partie(OUT)----- Enregistrement qui définit les cases source et case destination
valeur de retour : aucune valeur
void sauverPartie(type_partie &partie )
{
ofstream fichier;
int ligne;
char colonne;
char couleurajouer[6];//varable intermidiaire
char NomFichier[50];//varable intermidiaire
int etatpartie;//varable intermidiaire
strcpy(NomFichier, partie.NomPartie);
strcat(NomFichier, ".txt");
fichier.open(NomFichier);//ouverture du fichier texte
if(fichier.fail())
cout <<"Probleme de sauvegarde de la partie "<< NomFichier <<" !\n";
else
{
if(partie.JeuFini==1)//selon l'etat de la partie
etatpartie=partie.JeuFini;
else
etatpartie=partie.JeuPret;
fichier << " " << partie.NumeroCoupAJouer << " " << etatpartie << " ";
if(partie.TourAJouer == BLANC)//selon la couleur du tour a jouer
strcpy(couleurajouer , "BLANC") ;
else
strcpy(couleurajouer , "NOIR");
fichier << couleurajouer << endl;
for(ligne=7;ligne>=0;ligne--)//lire l'echiquier et sauver le reste de la partie
{
for(colonne='a';colonne<='h';colonne++)
{
if(partie.Echiquier[ligne][colonne - 'a'].Libre ==0)
{
fichier << " " << colonne << ligne + 1 << " ";
switch(partie.Echiquier[ligne][colonne-'a'].Piece)
{
case 00 :fichier<<"PION ";
break;
case 01 :fichier<<"CAVALIER ";
break;
case 02 :fichier<<"FOU ";
break;
case 03 :fichier<<"TOUR ";
break;
case 04 :fichier<<"DAME ";
break;
case 05 :fichier<<"ROI ";
break;
}
switch(partie.Echiquier[ligne][colonne-'a'].CouleurPiece)
{
case 00 : fichier << "BLANC " <<endl;break;
case 01 : fichier << "NOIR " <<endl;break;
}
}
}
}
fichier.close();
cout<<char (1)<< "la partie "<< NomFichier <<" est sauvegarder"<<char (1)<< endl;
}
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDGA KADJO Julien
description : fonction afficher menu
paramètres :
valeur de retour : aucune valeur
void afficher_menu()
{
cout<<setw(22)<<"*"<<"----------------------------*"<<endl;
cout<<setw(22)<<"*"<<"------MENU JEU D ECHEC------*"<<endl;
cout<<setw(22)<<"*"<<"----------------------------*"<<endl;
cout<<setw(25)<<"1-"<<"Initialiser une partie" <<endl;
cout<<setw(25)<<"2-"<<"Charger une partie" <<endl;
cout<<setw(25)<<"3-"<<"Afficher l'echequier" <<endl;
cout<<setw(25)<<"4-"<<"Jouer le prochain coup" <<endl;
cout<<setw(25)<<"5-"<<"Acceder a l'historique" <<endl;
cout<<setw(25)<<"6-"<<"Sauvegarder la partie en cours"<<endl;
cout<<setw(25)<<"7-"<<"Quitter"<<endl;
cout<<setw(30)<<"Donner votre choix (1...7) : ";
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDGA KADJO Julien
description : fonction vérifier reponse (test du choix)
paramètres : entier
valeur de retour : un entier
int verifier_reponse(int c)
{
for(int i=1 ; i<8 ; i++) //la saisi doit etre correcte(1...7)
{
if(c==i)
return i ;//retourne la saisi correcte
}
return -1 ;//valeur retourner quand la saisi est incorrect
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDGA KADJO Julien
description : fonction reponse (test du choix)
paramètres : aucun
valeur de retour : un entier
int Reponse()
{
int rep ;
do
{
scanf("%d", &rep) ;//lire la saisi
fflush(stdin); //clear le tampon d'entrée
if(verifier_reponse(rep)==-1)//si la saisi est incorrecte donner un autre choix
cout<<setw(30)<<"Donner votre choix (1...7) : ";
}
while (verifier_reponse(rep)==-1) ;//repater tant que la saisi est incorrecte
return (verifier_reponse(rep)) ; // retourne le nombre saisi correct
}
/**********************************************************************************************
auteurs : AFFAOUI Abdelghani _ EDGA KADJO Julien
description : fonction principale
Jeu d'echec simplifié
fait appel aux principales fonction du jeu d'echèc
paramètres : aucun
valeur de retour : aucune valeur
void main(void)
{
type_historique unhistorique;
type_partie unepartie;
bool initialiser=false;
bool bOk = true;
//prototype de la fonction reponse
int Reponse();
//prototype de la fonction verifier reponse
int verifier_reponse(int c);
//prototype de la fonction afficher menu
void afficher_menu();
// prototype de la fonction initialise l'echiquier
void ini_echiquier(type_partie& );
// prototype de la fonction charger l'echiquier
void charger_partie(type_partie &);
// prototype de la fonction jouer un coup
void jouer_prochain(type_partie &,type_historique & );
//prototype de la fonction acceder a l'historique
void AfficherCoupHistorique( const char NomPartie[], type_historique & );
//prototype de la fonction afficher l'echiquier
void aff_echiquier (type_partie);
//prototype de la fonction sauvegarder la partie
void sauverPartie(type_partie & partie);
unepartie.TourAJouer = BLANC; // initialisation de la couleur du joueur
unepartie.NumeroCoupAJouer=1; //initialisation du nbr des coups
do
{
afficher_menu();//appel de la fonction affichage menu
switch(Reponse()) //selon choix excute une ou des fonctions
{
case 1 :
{ini_echiquier(unepartie);
initialiser=true;
break;
}
case 2 :
{
if((unepartie.NumeroCoupAJouer > 0) && (initialiser=false))
{//si le nbr des coups jouer est>0
sauverPartie(unepartie ); //sauvegarde de la partie en cours
charger_partie(unepartie);
}
else
{
charger_partie(unepartie);
initialiser=true;
}
break;
}
case 3 :
{
if(initialiser==false)
cout<<"il n y pas de partie a afficher!"<<endl;
else
aff_echiquier (unepartie);
}
break;
case 4 :
{
if(initialiser==false)
cout<<"il n ya pas de partie a jouer"<<endl;
else
{
cout<<"Atoi : ";
switch(unepartie.TourAJouer)//signaler a qui le tour pour jouer
{
case 0 :cout<<"BLANC"<<endl;break;
case 01 :cout<<"NOIR"<<endl;break;
}
if(unepartie.JeuFini==0)
{
jouer_prochain(unepartie,unhistorique );
aff_echiquier (unepartie);
}
else
cout<<"la partie est fini!!!"<<endl;
}
}
break;
case 5 :
{
if(initialiser==false)
cout<<"il n ya pas de partie a consulter"<<endl;
else
{
AfficherCoupHistorique( unepartie.NomPartie, unhistorique);
}
}
break;
case 6 :
{
if(initialiser==false)
cout<<"il n ya pas de partie a sauvegarder"<<endl;
else
sauverPartie(unepartie);
}
break;
case 7 :
{
if(initialiser==true)
{
sauverPartie(unepartie );//sauver la partie avant de quitter
cout<<"Merci d avoir utiliser notre jeu d echec\n\n"
<<setw(25)<<"*** AU REVOIR *** \n\n";
}
else
{
cout<<"Merci d avoir utiliser notre jeu d echec\n\n"
<<setw(25)<<"*** AU REVOIR *** \n\n";
}
bOk = false;
}
break;
}
}while(bOk);//tant qu'on ne veux pas quitter la partie afficher menu
}
Conclusion :
Jeu d'echec simplifié fait appel aux principales fonction du jeu d'echèc
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.