Jeu d'echec simplifié

Soyez le premier à donner votre avis sur cette source.

Vue 8 271 fois - Téléchargée 627 fois

Description

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

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
40
j'ai posté ça il y a longtemps, ce code est foireux... si tu veux plus de détails et un code plus simle, tu peux lire mon jeu d'échec réseau en php...
Messages postés
5
Date d'inscription
dimanche 12 décembre 2004
Statut
Membre
Dernière intervention
21 mars 2005

Merc bcp
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
40
j'ai pas voulu tester ton jeu, j'ai juste regardé un peu les sources, il n'y a pas d'ia ...
J'ai pas très bien compris ta phrase dans ce qu'il reste a améliorer... tu cherches les règles du fou, ce que le fou a le droit de faire ?
Le fou avance uniquement en diagonale, regarde ce que ça donne pour le code :
if (piece==4){
/*si la pièce déplacée est un fou... Les fous vont en diagonales*/
printf("il y a un fou en (%d, %d)\n", a, b);
if ((x-a==y-b)||(x-a==-y+b)){
/*calcule t la taille du déplacement (le nombre de case traversée par le fou)*/
d=0;
if (a<x){
t=x-a;
}
else{
t=a-x;
}
for (i=1;i<t;i++){
/*Pour les quelques lignes suivantes, les coordonées des différentes cases traversés par le fou sont
calculés et placés dans e et f*/
if (a<x && b<y){
e=a+i;
f=b+i;
}
if (a<x && b>y){
e=a+i;
f=b-i;
}
if (a>x && b<y){
e=a-i;
f=b+i;
}
if (a>x && b>y){
e=a-i;
f=b-i;
}
printf("a=%d b=%d, a'=%d, b'=%d)\n", a, b, e, f);
if (*(ca+e*8+f)==0){
/*si la case est vide alors d augmente de 1, donc si a la fin, d est égal au nombre de case traversés,
alors le coup est légal.*/
d++;
}
}
if (d==t-1){
if (xd==100){
xd=a;
yd=b;
printf("coup legal!!!\n");
droit++;
printf("le fou va de (%d, %d) en (%d, %d)\n", a, b, xd, yd);
}else if(xd==a){
yd=b;
printf("coup legal!!!\n");
droit++;
printf("le fou va de (%d, %d) en (%d, %d)\n", a, b, x, y);
}else{
printf("ce fou n'est pas au bon endroit...\n");
}
}
}else{
printf("vous n'avancez pas en diagonales...\n");
}
}


J'ai pas fait gaffe aux noms de variables de ton fichier, j'éspère que tu t'y retrouvera (c'est un bout d'un jeu d'échec que j'ai créé, j'ai pas mis d'ia non plus, je la cherchais chez toi, pour m'inspirer de ton code, mais t'en a pas mis non plus...)
Messages postés
338
Date d'inscription
jeudi 22 août 2002
Statut
Membre
Dernière intervention
14 juin 2005

Le code paraît bien documenté :)

par contre, essaye de moins mélanger c et c++ : tu as des includes c++, tu utilises cout, les fstream + surcharges d'opérateur, mais par contre la structure de ton programme relève du c : pas de classes, utilisations des struct comme stockage d'informations uniquement, puis les #define : le c++ essaye d'eviter au maximum l'utilisation du préprocesseur donc #define MAX_CAR_NOM 50 => const int MAX_CAR_NOM = 50; et essayer de l'englober dans une classe (class MaClass { static const int MAX_CAR_NOM = 50; }; )
Messages postés
584
Date d'inscription
mardi 26 novembre 2002
Statut
Membre
Dernière intervention
29 mai 2015

Quelques remarques :
1) La capture d'écran me paraissait un tout petit peu plus jolie ;)
2) Tu utilises bcp d'informations en double. Par exemple, chaque case est libre ou non, est blanche ou noire, contient un type de piece, d'une certain couleur. Soit un booleén (4 octets) et 3 int (4 octets chacun). Tu pourrais définir une piece qui s'appellerait VIDE et dire que si la piece est VIDE c'est que la case est VIDE et sinon elle n'est pas vide ! Pareil pour la couleur : tu pourrais faire des pieces de type CAVALIER_BLANC CAVALIER_NOIR, ... Bref tu pourrais gagner de la place.
3) Ce programme est incroyablement peu pratique à utiliser ... :(

Mais c'est pas mal pour comprendre un peu les progs en C et les opérations sur les fichiers.

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.