Jeu de Dames en c++

**paul.spt** · 13/04/2023, 10h30

Bonjour, je suis débutant en c++ et je suis en train de créer un jeu de Dames. Cependant, j'ai quelques problèmes avec le déplacement de mes pions. Plus particulièrement avec celui des dames (les pions rois). Je voudrais qu'elles puissent se déplacer sur une même diagonale d'autant de cases qu'elles le désirent, en avant et en arrière. Tout ca en pouvant aussi sauter des pions. Pouvez vous m'aider ?main.cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
#include <iostream>
#include <windows.h>
 
using namespace std;
 
char board[8][8] =
        {
                {' ', 'n', ' ', 'n', ' ', 'n', ' ', 'n'},
                {'n', ' ', 'n', ' ', 'n', ' ', 'n', ' '},
                {' ', 'n', ' ', 'n', ' ', 'n', ' ', 'n'},
                {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
                {' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
                {'b', ' ', 'b', ' ', 'b', ' ', 'b', ' '},
                {' ', 'b', ' ', 'b', ' ', 'b', ' ', 'b'},
                {'b', ' ', 'b', ' ', 'b', ' ', 'b', ' '},
        };
 
char turn = 'B';
bool leap;
bool game_running = true;
int row1, row2, column1, column2;
int black_piece = 12;
int white_piece = 12;
 
void display_board();
void input();
bool check_move();
bool check_blocked();
void move();
void do_leap();
void king();
void game_over();
 
int main()
{
    SetConsoleOutputCP(CP_UTF8);
    cout << "---Jeu de Dames---\n";
    cout << "Joueur 1 [n]\n";
    cout << "Joueur 2 [b]\n\n";
    cout << "Une lettre capitale represente un pion roi\n";
    cout << "Veuillez redimensionner votre fenêtre de ligne de commande afin que cette ligne tienne à l'écran:\n";
    cout << "_____________________________________________________________________________________\n\n";
    cout << "Appuyez sur entrée pour commencer...";
    cin.get(); // On attend que le joueur appuie sur entrée pour continuer
 
    // La boucle qui fait tourner le jeu
    while (game_running)
    {
        display_board();
 
        if (turn == 'N')
        {
            cout << "--Joueur 1 [N]--\n";
        }
        else if (turn == 'B')
        {
            cout << "--Joueur 2 [B]--\n";
        }
 
        input();
        move();
        king();
        game_over();
    }
 
    // Determiner le gagnant à la fin
    if (turn == 'N')
    {
        cout << endl << endl << "Joueur 2 [Blanc] gagne!\n";
    }
    else if (turn == 'B')
    {
        cout << endl << endl << "Joueur 1 [Noir] gagne!\n";
    }
 
    cout << "GAME OVER!\n";
}
 
// Afficher le damier
void display_board()
{
    cout << "==================================================================================\n\n\n\n";
    cout << "       0         1         2         3         4         5         6         7     \n";
    cout << "  _________________________________________________________________________________\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "0 |    " << board[0][0] << "    |    " << board[0][1] << "    |    " << board[0][2] << "    |    "  << board[0][3] << "    |    " << board[0][4] << "    |    " << board[0][5] << "    |    " << board[0][6] << "    |    " << board[0][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "1 |    " << board[1][0] << "    |    " << board[1][1] << "    |    " << board[1][2] << "    |    "  << board[1][3] << "    |    " << board[1][4] << "    |    " << board[1][5] << "    |    " << board[1][6] << "    |    " << board[1][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "2 |    " << board[2][0] << "    |    " << board[2][1] << "    |    " << board[2][2] << "    |    "  << board[2][3] << "    |    " << board[2][4] << "    |    " << board[2][5] << "    |    " << board[2][6] << "    |    " << board[2][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "3 |    " << board[3][0] << "    |    " << board[3][1] << "    |    " << board[3][2] << "    |    "  << board[3][3] << "    |    " << board[3][4] << "    |    " << board[3][5] << "    |    " << board[3][6] << "    |    " << board[3][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "4 |    " << board[4][0] << "    |    " << board[4][1] << "    |    " << board[4][2] << "    |    "  << board[4][3] << "    |    " << board[4][4] << "    |    " << board[4][5] << "    |    " << board[4][6] << "    |    " << board[4][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "5 |    " << board[5][0] << "    |    " << board[5][1] << "    |    " << board[5][2] << "    |    "  << board[5][3] << "    |    " << board[5][4] << "    |    " << board[5][5] << "    |    " << board[5][6] << "    |    " << board[5][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "6 |    " << board[6][0] << "    |    " << board[6][1] << "    |    " << board[6][2] << "    |    "  << board[6][3] << "    |    " << board[6][4] << "    |    " << board[6][5] << "    |    " << board[6][6] << "    |    " << board[6][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "7 |    " << board[7][0] << "    |    " << board[7][1] << "    |    " << board[7][2] << "    |    "  << board[7][3] << "    |    " << board[7][4] << "    |    " << board[7][5] << "    |    " << board[7][6] << "    |    " << board[7][7] << "    |\n";
    cout << "  |         |         |         |         |         |         |         |         |\n";
    cout << "  |_________|_________|_________|_________|_________|_________|_________|_________|\n";
    cout << "       0         1         2         3         4         5         6         7     \n";
}
 
// Prendre la réponse de l'utilisateur
void input()
{
    cout << "Nombre de pion blancs: " << white_piece << ", Nombre de pions noirs: " << black_piece << endl;
    cout << "Déplacer une pièce\n";
    cout << "Ligne: ";
    cin >> row1;
    cout << "Colonne: ";
    cin >> column1;
 
    while (row1 < 0 || row1 > 7 || column1 < 0 || column1 > 7)
    {
        cout << "Entrée incorrecte. Entrez des nombres entre 0 et 7.\n";
        cout << "Déplacer une pièce\n";
        cout << "Ligne: ";
        cin >> row1;
        cout << "Colonne: ";
        cin >> column1;
    }
 
    cout << "Vers la case\n";
    cout << "Ligne: ";
    cin >> row2;
    cout << "Colonne: ";
    cin >> column2;
 
    while (row2 < 0 || row2 > 7 || column2 < 0 || column2 > 7)
    {
        cout << "Entrée incorrecte. Entrez des nombres entre 0 et 7.\n";
        cout << "Vers la case\n";
        cout << "Ligne: ";
        cin >> row2;
        cout << "Colonne: ";
        cin >> column2;
    }
 
    while (check_move() == false)
    {
        cout << "MOUVEMENT INTERDIT!\n";
        input();
    }
}
 
// Verifier si le mouvement est valide
bool check_move()
{
    // Vérifier si une pièce autre que le roi recule
    if (board[row1][column1] != 'N' && board[row1][column1] != 'B')
    {
        if ((turn == 'N' && row2 < row1) || (turn == 'B' && row2 > row1))
        {
            cout << "Impossible de reculer.\n";
            leap = false;
            return false;
        }
    }
 
    // Vérifie si l'emplacement vers lequel la pièce se déplace est déjà pris
    if (board[row2][column2] != ' ')
    {
        cout << "Case de destination déjà occupée.\n";
        leap = false;
        return false;
    }
 
    // Vérifier si l'emplacement entré par l'utilisateur contient une pièce à déplacer
    if (board[row1][column1] == ' ')
    {
        cout << "Il n'y a pas de pion à l'emplacement de départ.\n";
        leap = false;
        return false;
    }
 
    // Vérifier si la pièce ne se déplace pas en diagonale
    if (column1 == column2 || row1 == row2)
    {
        cout << "Les pions ne peuvent se déplacer qu'en diagonale.\n";
        leap = false;
        return false;
    }
 
    // Vérifier si la pièce se déplace de plus d'une colonne et d'une seule ligne
    if (board[row1][column1] != 'N' && board[row1][column1] != 'B')
    {
        if ((column2 > column1 + 1 || column2 < column1 - 1) && (row2 == row1 +1 || row2 == row1 - 1)) {
            cout << "Les pions ne peuvent pas se deplacer de plus d'une colonne/ligne.\n";
            leap = false;
            return false;
        }
    }
 
    // Vérifier si la pièce saute
    if (row2 > row1 + 1 || row2 < row1 - 1)
    {
        // Vérifier si la pièce saute trop loin
        if (row2 > row1 + 2 || row2 < row1 - 2)
        {
            cout << "Le pion est sauté trop loin.\n";
            leap = false;
            return false;
        }
 
        // Vérifier si la pièce ne se déplace pas d'exactement 2 colonnes
        if (board[row1][column1] != 'N' && board[row1][column1] != 'B') {
            if (column2 != column1 + 2 && column2 != column1 - 2) {
                cout << "Le pion ne peut pas se deplacer de deux colones.\n";
                leap = false;
                return false;
            }
        }
 
        // Vérifier si la pièce saute par-dessus une autre pièce de l'autre joueur
        char otherPlayer;
        if (toupper(board[row1][column1]) == 'B') {
            otherPlayer = 'N';
        } else {
            otherPlayer = 'B';
        }
 
        if (row2 > row1 && column2 > column1)
        {
            if (toupper(board[row2 - 1][column2 - 1]) != otherPlayer)
            {
                leap = false;
                return false;
            }
        }
        else if (row2 > row1 && column2 < column1)
        {
            if (toupper(board[row2 - 1][column2 + 1]) != otherPlayer)
            {
                leap = false;
                return false;
            }
        }
        else if (row2 < row1 && column2 > column1)
        {
            if (toupper(board[row2 + 1][column2 - 1]) != otherPlayer)
            {
                leap = false;
                return false;
            }
        }
        else if (row2 < row1 && column2 < column1)
        {
            if (toupper(board[row2 + 1][column2 + 1]) != otherPlayer)
            {
                leap = false;
                return false;
            }
        }
        leap = true;
        return true;
    }
    leap = false;
    return true;
}
 
// Executer un mouvement
void move()
{
    bool king_piece = false;
 
    if (board[row1][column1] == 'N' || board[row1][column1] == 'B')
    {
        king_piece = true;
    }
 
    board[row1][column1] = ' ';
 
    if (turn == 'N')
    {
        if (king_piece == false)
        {
            board[row2][column2] = 'n';
        }
        else if (king_piece == true)
        {
            board[row2][column2] = 'N';
        }
 
        turn = 'B';
    }
    else if (turn == 'B')
    {
        if (king_piece == false)
        {
            board[row2][column2] = 'b';
        }
        else if (king_piece == true)
        {
            board[row2][column2] = 'B';
        }
 
        turn = 'N';
    }
 
    if (leap == true)
     {
        // Déterminer la couleur de la pièce mangée
        int mid_row = (row1 + row2) / 2;
        int mid_col = (column1 + column2) / 2;
        char jumped_piece = board[mid_row][mid_col];
        // Enlever la pièce mangée et mettre à jour le compteur correspondant
        if (jumped_piece == 'n'){
            black_piece--;
        }
        else if (jumped_piece == 'b'){
            white_piece--;
        }
        board[mid_row][mid_col] = ' ';
 
        do_leap();
    }
}
 
// Effectue un saut par-dessus un pion
void do_leap()
{
    char answer;
 
    // Supprime le damier après le saut
    if (row2 > row1 && column2 > column1)
    {
        board[row2 - 1][column2 - 1] = ' ';
    }
    else if (row2 > row1 && column2 < column1)
    {
        board[row2 - 1][column2 + 1] = ' ';
    }
    else if (row2 < row1 && column2 > column1)
    {
        board[row2 + 1][column2 - 1] = ' ';
    }
    else if (row2 < row1 && column2 < column1)
    {
        board[row2 + 1][column2 + 1] = ' ';
    }
 
    display_board(); // Affiche le tableau après les modifications
 
    // Demande si l'utilisateur veut sauter à nouveau
    do
    {
        cout << "Vous venez de sauter une fois. Voulez-vous essayer une seconde (o/n):";
        cin >> answer;
    }
    while (answer != 'O' && answer != 'o' && answer != 'N' && answer != 'n');
 
    if (answer == 'o' || answer == 'O')
    {
        row1 = row2;
        column1 = column2;
        cout << "Saut de pion: ligne: " << row1 << ", colonne: " << column1 << endl;
        cout << "Vers la case\n";
        cout << "Ligne: ";
        cin >> row2;
        cout << "Colonne: ";
        cin >> column2;
 
        while (row2 < 0 || row2 > 7 || column2 < 0 || column2 > 7)
        {
            cout << "Entrée incorrecte. Entrez des nombres entre 0 et 7.\n";
            cout << "Vers la case\n";
            cout << "Ligne: ";
            cin >> row2;
            cout << "Colonne: ";
            cin >> column2;
        }
 
        if (turn == 'N')
        {
            turn = 'B';
        }
        else if (turn == 'B')
        {
            turn = 'N';
        }
 
        check_move();
 
        if (leap == false)
        {
            cout << "MOUVEMENT INTERDIT!\n";
 
            if (turn == 'N')
            {
                turn = 'B';
            }
            else if (turn == 'B')
            {
                turn = 'N';
            }
        }
        else if (leap == true)
        {
            move();
        }
    }
}
 
/*
// Regarde si un joueur est bloqué car il ne peut plus jouer et donc perd la partie
bool check_blocked() {
    // Parcours le plateau de jeu
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            // Vérifie si la pièce appartient au joueur actuel
            if (board[i][j] == turn || board[i][j] == toupper(turn)) {
                // Vérifie si la pièce a des mouvements possibles
                if (i > 0 && j > 0 && board[i-1][j-1] == ' ') {
                    return false;
                }
                if (i > 0 && j < 7 && board[i-1][j+1] == ' ') {
                    return false;
                }
                if (i < 7 && j > 0 && board[i+1][j-1] == ' ') {
                    return false;
                }
                if (i < 7 && j < 7 && board[i+1][j+1] == ' ') {
                    return false;
                }
                if (toupper(board[i][j]) == 'N') {
                    if (i > 1 && j > 1 && board[i-1][j-1] != ' ' && (board[i-1][j-1] != turn && board[i-2][j-2] == ' ')) {
                        return false;
                    }
                    if (i > 1 && j < 6 && board[i-1][j+1] != ' ' && (board[i-1][j+1] != turn && board[i-2][j+2] == ' ')) {
                        return false;
                    }
                } else {
                    if (i < 6 && j > 1 && board[i+1][j-1] != ' ' && (board[i+1][j-1] != turn && board[i+2][j-2] == ' ')) {
                        return false;
                    }
                    if (i < 6 && j < 6 && board[i+1][j+1] != ' ' && (board[i+1][j+1] != turn && board[i+2][j+2] == ' ')) {
                        return false;
                    }
                }
            }
        }
    }
    // Si aucun mouvement n'est possible pour le joueur actuel, le joueur est bloqué
    return true;
}
*/
 
// Convertire les pièces de dames basiques qui ont atteint l'autre côté du plateau en pièces de roi
void king()
{
    for (int i = 0; i < 8; i++)
    {
        if (board[0][i] == 'b')
        {
            board[0][i] = 'B';
        }
 
        if (board[7][i] == 'n')
        {
            board[7][i] = 'N';
        }
    }
}
 
// Determiner si la partie est finie
void game_over()
{
    // End the game if a player has no more pieces
    if (black_piece == 0 || white_piece == 0){
        game_running = false;
    }
    /*
    else if (check_blocked()) {
        // Si un joueur est bloqué, la partie est terminée et l'autre joueur remporte la partie
        game_running = false;
        if (turn == 'b') {
            std::cout << "Les noirs ont gagné!" << std::endl;
        }
        else {
            std::cout << "Les blancs ont gagné!" << std::endl;
        }
    }
    */
}

**koala01** · 16/04/2023, 14h10

Salut,

Pour jouer aux dames, il te faut deux choses en priorité:

"quelque chose" pour représenter le plateau de jeu en lui-même (cela peut être un simple tableau à deux dimensions dont chaque case représente une des case du jeu) et
"quelque chose" pour représenter la notion de "pion"

Dans l'idéal, ces deux choses devraient être en mesure de répondre à un certain nombre de questions "relativement simples" comme:

Pour ce qui représente le plateau de jeu:

Telle case (identifiée par la ligne et la colonne recherchée) est elle une case valide? étant donné que seules les cases noires sont effectivement valide
Telle case (valide) contient elle un pion? et si oui,
- quelle est la couleur du pion qui se trouve sur cette case?

Et pour ce qui représente la notion de pion, ce serait des questions comme:

Quelle est la couleur du pion?
Le pion est-il une dame?
Quelle est la position de ce pion (fournie au travers d'un numéro de ligne et d'un numéro de colonne)?

Une fois que tu auras ces possibiltiés, les choses deviendront beaucoup plus faciles, car tu disposeras de l'ensemble des informations permettant de déterminer quels sont les déplacements que tu peux faire. Il ne te restera donc "plus qu'à" ajouter une dernière question à la notion de pions : Quels sont les déplacements qui sont valide pour ta situation actuelle? Le tout en sachant qu'un déplacement est -- d'office -- la "mise en commun" de deux positions sur le plateau, que la première est ** forcément ** la case sur laquelle se trouve le pion observé, et que la deuxième est ... la position vers laquelle il peut envisager d'aller

Jeu de Dames en c++

C++

Vue hybride

Discussions similaires

Partager

Partager