Jeu d'echec
Creation d'un jeu d'echec
Chargement...
Recherche...
Aucune correspondance
Référence de la classe Game

Classe Game contenant les informations sur la partie. Plus de détails...

#include <game.hh>

Fonctions membres publiques

 Game ()
 Constructeur de la classe Game qui initialise la partie.
 
PiecegetPiece (int x, int y)
 retourne la pièce à la position x,y
 
void resetEnPassant ()
 permet de remettre à zéro les pièces qui peuvent être prises en passant
 
int pathIsClear (int x1, int y1, int x2, int y2)
 vérifie si le chemin entre deux cases est libre
 
GameState getState ()
 retourne l'état de la partie (en cours, quitté, blanc/noir gagne, pat)
 
void play ()
 récupère le mouvement du joueur et le joue si il est légal, sinon redemande un mouvement
 
void quitGame ()
 affiche les statistiques en fin de partie
 
void printBoard ()
 affiche le plateau de jeu
 
 ~Game ()
 

Description détaillée

Classe Game contenant les informations sur la partie.

Documentation des constructeurs et destructeur

◆ Game()

Game::Game ( )

Constructeur de la classe Game qui initialise la partie.

13 {
14 check = false;
15 turn = 1;
16 state = inProgess;
17 piecesB[0] = new Rook(Black, file_a, rank_8);
18 piecesB[1] = new Knight(Black, file_b, rank_8);
19 piecesB[2] = new Bishop(Black, file_c, rank_8);
20 piecesB[3] = new Queen(Black, file_d, rank_8);
21 piecesB[4] = new King(Black, file_e, rank_8);
22 piecesB[5] = new Bishop(Black, file_f, rank_8);
23 piecesB[6] = new Knight(Black, file_g, rank_8);
24 piecesB[7] = new Rook(Black, file_h, rank_8);
25
26 piecesW[0] = new Rook(White, file_a, rank_1);
27 piecesW[1] = new Knight(White, file_b, rank_1);
28 piecesW[2] = new Bishop(White, file_c, rank_1);
29 piecesW[3] = new Queen(White, file_d, rank_1);
30 piecesW[4] = new King(White, file_e, rank_1);
31 piecesW[5] = new Bishop(White, file_f, rank_1);
32 piecesW[6] = new Knight(White, file_g, rank_1);
33 piecesW[7] = new Rook(White, file_h, rank_1);
34 for (int i(0); i < 8; i++) {
35 piecesB[i + 8] = new Pawn(Black, i, rank_7);
36 piecesW[i + 8] = new Pawn(White, i, rank_2);
37 }
38 filePartie.open("partie.txt");
39
40 savePositions();
41 updateBoard();
42}
@ inProgess
Definition chess.hh:40
@ White
Definition chess.hh:7
@ Black
Definition chess.hh:7
@ rank_7
Definition chess.hh:36
@ rank_1
Definition chess.hh:30
@ rank_2
Definition chess.hh:31
@ rank_8
Definition chess.hh:37
@ file_g
Definition chess.hh:26
@ file_h
Definition chess.hh:27
@ file_b
Definition chess.hh:21
@ file_c
Definition chess.hh:22
@ file_a
Definition chess.hh:20
@ file_d
Definition chess.hh:23
@ file_e
Definition chess.hh:24
@ file_f
Definition chess.hh:25
sous classe Bishop qui contient le code utf de la piece et son mouvement
Definition piece.hh:96
sous classe King qui contient le code utf de la piece et son mouvement
Definition piece.hh:116
sous classe Knight qui contient le code utf de la piece et son mouvement
Definition piece.hh:106
sous classe Pawn qui contient le code utf de la piece et son mouvement
Definition piece.hh:76
sous classe Queen qui contient le code utf de la piece et son mouvement
Definition piece.hh:126
sous classe Rook qui contient le code utf de la piece et son mouvement
Definition piece.hh:86

◆ ~Game()

Game::~Game ( )
45 {
46 for (int i(0); i < 16; i++) {
47 delete piecesB[i];
48 delete piecesW[i];
49 }
50 filePartie.close();
51}

Documentation des fonctions membres

◆ getPiece()

Piece * Game::getPiece ( int  x,
int  y 
)

retourne la pièce à la position x,y

Paramètres
xcoordonnée x de la case
ycoordonnée y de la case
Renvoie
Piece*
220{ return board[x][y].piece; }
Piece * piece
Definition square.hh:12

◆ getState()

GameState Game::getState ( )

retourne l'état de la partie (en cours, quitté, blanc/noir gagne, pat)

Renvoie
enum GameState
112{ return state; }

◆ pathIsClear()

int Game::pathIsClear ( int  x1,
int  y1,
int  x2,
int  y2 
)

vérifie si le chemin entre deux cases est libre

Paramètres
x1coordonnée x de la case de départ
y1coordonnée y de la case de départ
x2coordonnée x de la case d'arrivée
y2coordonnée y de la case d'arrivée
Renvoie
retourne 1 si le chemin est libre, 0 sinon
153 {
154 // déplacement vertical
155 if (x1 == x2) {
156 if (y1 < y2) {
157 for (int i(y1 + 1); i < y2; i++) {
158 if (board[x1][i].piece != nullptr) {
159 return 0;
160 }
161 }
162 } else {
163 for (int i(y1 - 1); i > y2; i--) {
164 if (board[x1][i].piece != nullptr) {
165 return 0;
166 }
167 }
168 }
169 }
170 // déplacement horizontal
171 else if (y1 == y2) {
172 if (x1 < x2) {
173 for (int i(x1 + 1); i < x2; i++) {
174 if (board[i][y1].piece != nullptr) {
175 return 0;
176 }
177 }
178 } else {
179 for (int i(x1 - 1); i > x2; i--) {
180 if (board[i][y1].piece != nullptr) {
181 return 0;
182 }
183 }
184 }
185
186 }
187 // déplacement diagonal
188 else if (x1 < x2) {
189 if (y1 < y2) {
190 for (int i(1); i < x2 - x1; i++) {
191 if (board[x1 + i][y1 + i].piece != nullptr) {
192 return 0;
193 }
194 }
195 } else {
196 for (int i(1); i < x2 - x1; i++) {
197 if (board[x1 + i][y1 - i].piece != nullptr) {
198 return 0;
199 }
200 }
201 }
202 } else {
203 if (y1 < y2) {
204 for (int i(1); i < x1 - x2; i++) {
205 if (board[x1 - i][y1 + i].piece != nullptr) {
206 return 0;
207 }
208 }
209 } else {
210 for (int i(1); i < x1 - x2; i++) {
211 if (board[x1 - i][y1 - i].piece != nullptr) {
212 return 0;
213 }
214 }
215 }
216 }
217 return 1;
218}

◆ play()

void Game::play ( )

récupère le mouvement du joueur et le joue si il est légal, sinon redemande un mouvement

54 {
55 do {
56 if (check) {
57 cout << "check" << endl;
58 }
59 getmove();
60 if (move == "/quit") {
61 state = quit;
62 return;
63 }
64 if (move == "O-O") {
65 if (shortCastling()) {
66 cout << "short castling" << endl;
67 break;
68 }
69 }
70 if (move == "O-O-O") {
71 if (longCastling()) {
72 cout << "long castling" << endl;
73 break;
74 }
75 } else {
76 moveInt[0] = moveToFile(0);
77 moveInt[1] = moveToRank(1);
78 moveInt[2] = moveToFile(2);
79 moveInt[3] = moveToRank(3);
80 }
81 } while (!movePiece());
82 updateBoard();
83 if (isCheck(turn)) {
84 cout << "This move put in check" << endl;
85 undoMove();
86 play();
87 return;
88 }
89 while (!promotePawn()) {
90 }
91 filePartie << move << endl;
92 savePositions();
93 if (isCheck(!turn)) {
94 if (isCheckMate(!turn)) {
95 if (turn == White) {
96 state = WhiteWin;
97 } else {
98 state = BlackWin;
99 }
100 return;
101 }
102 check = true;
103 } else {
104 if (isStalemate(!turn)) {
105 state = Stalemate;
106 return;
107 }
108 }
109 turn = !turn;
110}
@ quit
Definition chess.hh:40
@ BlackWin
Definition chess.hh:40
@ Stalemate
Definition chess.hh:40
@ WhiteWin
Definition chess.hh:40
void play()
récupère le mouvement du joueur et le joue si il est légal, sinon redemande un mouvement
Definition game.cc:54

◆ printBoard()

void Game::printBoard ( )

affiche le plateau de jeu

524 {
525 updateBoard();
526
527 for (int i(0); i < 64; i++) {
528 board[i / 8][i % 8].updateUtf();
529 }
530 cout << " a b c d e f g h " << endl;
531 cout << " ┌───┬───┬───┬───┬───┬───┬───┬───┐" << endl;
532 for (int i(7); i >= 0; i--) {
533 cout << i + 1 << " │ ";
534 for (int j(0); j < 8; j++) {
535 cout << board[j][i].utf << " │ ";
536 }
537 cout << endl;
538 if (i) {
539 cout << " ├───┼───┼───┼───┼───┼───┼───┼───┤" << endl;
540 }
541 }
542 cout << " └───┴───┴───┴───┴───┴───┴───┴───┘" << endl;
543}
string utf
contient le caractère unicode de la case
Definition square.hh:18
void updateUtf()
met à jour le caractère unicode de la case
Definition square.cc:5

◆ quitGame()

void Game::quitGame ( )

affiche les statistiques en fin de partie

546 {
547 updateBoard();
548 // affichage du résultat de la partie
549 switch (state) {
550 case WhiteWin:
551 cout << "White Win" << endl;
552 break;
553 case BlackWin:
554 cout << "Black Win" << endl;
555 break;
556 case Stalemate:
557 cout << "Stalemate" << endl;
558 break;
559 case quit:
560 cout << "Game quited" << endl;
561 break;
562 default:
563 break;
564 }
565 cout << endl;
566 // affichage de l'échiquier
567 for (int i = 0; i < 8; i++) {
568 for (int j = 0; j < 8; j++) {
569 if (board[j][i].piece != nullptr) {
570 if (board[j][i].piece->color == White) {
571 cout << "w";
572 } else {
573 cout << "b";
574 }
575
576 cout << board[j][i].piece->id;
577 }
578 cout << ",";
579 }
580 }
581 // affichage du résultat de la partie
582 switch (state) {
583 case WhiteWin:
584 cout << " 1-0" << endl;
585 break;
586 case BlackWin:
587 cout << " 0-1" << endl;
588 break;
589 case Stalemate:
590 cout << " 1/2-1/2" << endl;
591 break;
592 case quit:
593 cout << " ?-?" << endl;
594 break;
595 default:
596 cout << " ?-?" << endl;
597 break;
598 }
599}
PieceType id
type de la pièce
Definition piece.hh:20

◆ resetEnPassant()

void Game::resetEnPassant ( )

permet de remettre à zéro les pièces qui peuvent être prises en passant

224 {
225 for (int i(0); i < 8; i++) {
226 for (int j(0); j < 8; j++) {
227 if (board[i][j].piece != nullptr) {
228 if (board[i][j].piece->color == turn) {
229 board[i][j].piece->EnPassant = false;
230 }
231 }
232 }
233 }
234}
bool EnPassant
true si la pièce peut être prise en passant
Definition piece.hh:35

La documentation de cette classe a été générée à partir des fichiers suivants :