Projet de démineur dans le terminal

Version imprimable

Bonjour à vous,

J'ai pour projet de coder un jeu de démineur en C. Il doit fonctionner avec le terminal donc pas de bibliothèque graphique.
Je bloque sur le fait de dévoiler TOUTES les cases vides à proximité de la case choisie par l'utilisateur SI cette dernière est vide.

Comment auriez-vous fait ?

Je poste mon code actuel (non optimisé, tout brouillon) si cela peut être utile à la compréhension.

Merci d'avance.

Code:

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
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <string.h>
#include <unistd.h>
#define TAILLE 9
 
void clear_scan(){
	char c;
	int res;
	do{
		res=fscanf(stdin, "%c", &c);
	}while(res==1 && c!= '\n');
}
 
char haha (int p){
	char z = '0';
	char X = '1';
	char _ = '2';
	char O = '3';
	char E = '4';
 
	if ( p == 0 ) {
		return(z);
	}
	else if ( p == 1 ) {
		return(X);
	}
	else if ( p == 2 ) {
		return(_);
	}
	else if ( p == 3 ) {
		return(O);
	}
	else {  
		return(E);
 
	}
}
 
void affiche_plateau(int plateau[TAILLE][TAILLE]){
	printf("   A B C D E F G H I \n");
	int i,j;
	for (i=0;i<TAILLE;i++){
		printf("%d |",i);
		for (j=0;j<TAILLE;j++){
			printf("%c|",plateau[i][j]);
		}
	printf("\n");
	}
	printf("\n");
}
 
int verif_case(int tab[TAILLE][TAILLE], int col, int lig){
	if (tab[col][lig] == 'x'){
		return 0;
	}
	return 1;
}
 
void placer_bombe(int tab[TAILLE][TAILLE]){
	int col,lig,c,d;
	for(int i = 0; i < 10; i++){
		col = rand()%9;
		lig = rand()%9;
		c =verif_case(tab,col,lig);
		if (c == 1){
			tab[col][lig] = 'x';
 
		}
		else{
			i--;
		}
	}
}
 
void remplir_tab(int tab[TAILLE][TAILLE]){
	for (int i = 0; i < TAILLE ; i++){
		for ( int j = 0 ; j < TAILLE ; j ++){
			tab[i][j] = ' ';
		}
	}
}
 
int remplissage_case(int tab[TAILLE][TAILLE],int lig,int col, int bombeA){
	for(int i=0; i<TAILLE; i++){
		for(int j=0; j<TAILLE; j++){
			if(tab[i][j]=='~'){
				tab[i][j] = '~';
			}
		}
 
	}
	if (bombeA==0) {
		tab[lig][col]='~';
	}
	else {
		tab[lig][col]=haha(bombeA);
	}
 
}
 
int mine_autour_sc(int tab[TAILLE][TAILLE], int lig, int col){
	int detection;
	detection = 0;
 
	if ( tab[lig-1][col-1] == 'x'){
		detection++;
	}
	if ( tab[lig+1][col+1] == 'x'){
		detection++;
	}
	if ( tab[lig-1][col+1] == 'x'){
		detection++;
	}
	if ( tab[lig+1][col-1] == 'x'){
		detection++;
	}
	if ( tab[lig][col-1] == 'x'){
		detection++;
	}
	if ( tab[lig-1][col] == 'x'){
		detection++;
	}
	if ( tab[lig+1][col] == 'x'){
		detection++;
	}
	if ( tab[lig][col+1] == 'x'){
		detection++;
	}
	return detection;
}
 
int mine_autour_cg(int tab[TAILLE][TAILLE], int lig, int col){
	int detection;
	detection = 0;
	if ( lig != 0 && lig != 8){
		if ( tab[lig-1][col] == 'x'){
		detection++;
		}
		if ( tab[lig+1][col] == 'x'){
		detection++;
		}
		if ( tab[lig-1][col+1] == 'x'){
		detection++;
		}
		if ( tab[lig][col+1] == 'x'){
			detection++;
		}
		if ( tab[lig+1][col+1] == 'x'){
			detection++;
		}
	}
	if ( lig == 0){
		if ( tab[lig+1][col] == 'x'){
		detection++;
		}
		if ( tab[lig][col+1] == 'x'){
			detection++;
		}
		if ( tab[lig+1][col+1] == 'x'){
			detection++;
		}
	}
	if ( lig == 8){
		if ( tab[lig-1][col] == 'x'){
		detection++;
		}
		if ( tab[lig-1][col+1] == 'x'){
			detection++;
		}
		if ( tab[lig][col+1] == 'x'){
			detection++;
		}
	}
	return detection;
}
 
int mine_autour_cd(int tab[TAILLE][TAILLE], int lig, int col){
	int detection;
	detection = 0;
	if ( lig != 0 && lig != 8){
		if ( tab[lig-1][col] == 'x'){
		detection++;
		}
		if ( tab[lig+1][col] == 'x'){
		detection++;
		}
		if ( tab[lig-1][col-1] == 'x'){
		detection++;
		}
		if ( tab[lig][col-1] == 'x'){
			detection++;
		}
		if ( tab[lig+1][col-1] == 'x'){
			detection++;
		}
	}
	if ( lig == 0){
		if ( tab[lig][col-1] == 'x'){
		detection++;
		}
		if ( tab[lig-1][col-1] == 'x'){
			detection++;
		}
		if ( tab[lig+1][col] == 'x'){
			detection++;
		}
	}
	if ( lig == 8){
		if ( tab[lig-1][col] == 'x'){
		detection++;
		}
		if ( tab[lig-1][col-1] == 'x'){
			detection++;
		}
		if ( tab[lig][col-1] == 'x'){
			detection++;
		}
	}
	return detection;
}
 
int mine_autour_chsc(int tab[TAILLE][TAILLE], int lig, int col){
	int detection;
	detection = 0;
	if ( tab[lig][col-1] == 'x'){
		detection++;
	}
	if ( tab[lig+1][col-1] == 'x'){
			detection++;
	}
	if ( tab[lig+1][col] == 'x'){
			detection++;
	}
	if ( tab[lig+1][col+1] == 'x'){
			detection++;
	}
	if ( tab[lig][col+1] == 'x'){
			detection++;
	}
	return detection;
}
 
int mine_autour_cbsc(int tab[TAILLE][TAILLE], int lig, int col){
	int detection;
	detection = 0;
	if ( tab[lig][col-1] == 'x'){
		detection++;
	}
	if ( tab[lig-1][col-1] == 'x'){
			detection++;
	}
	if ( tab[lig-1][col+1] == 'x'){
			detection++;
	}
	if ( tab[lig-1][col] == 'x'){
			detection++;
	}
	if ( tab[lig][col+1] == 'x'){
			detection++;
	}
	return detection;
}
 
void mine_autour(int tab[TAILLE][TAILLE]){
	int detection;
	detection = 0;
	for(int i = 0;i<TAILLE;i++){
		detection = mine_autour_cg(tab,i,0);
		if(detection != 0 && tab[i][0] != 'x'){
			tab[i][0] = haha(detection);	
		}
	}
	for(int i = 1; i < TAILLE-1;i++){
		for(int j = 1;j<TAILLE-1;j++){
		detection = mine_autour_sc(tab,i,j);
			if(detection != 0 && tab[i][j] != 'x'){
				tab[i][j] = haha(detection);
			}
		}
	}
	for(int j = 1; j < TAILLE-1; j++){
		detection = mine_autour_chsc(tab,0,j);
		if(detection != 0 && tab[0][j] != 'x'){
			tab[0][j] = haha(detection);	
		}
	}
	for(int j = 1; j < TAILLE-1; j++){
		detection = mine_autour_cbsc(tab,8,j);
		if(detection != 0 && tab[8][j] != 'x'){
			tab[8][j] = haha(detection);	
		}
	}
	for(int i = 0;i<TAILLE;i++){
		detection = mine_autour_cd(tab,i,8);
		if(detection != 0 && tab[i][8] != 'x'){
			tab[i][8] = haha(detection);	
		}
	}
}
 
void fonc_devoile( int tab[TAILLE][TAILLE] , int tab2[TAILLE][TAILLE], int lig, int col){
	col = col - 1;
	int bombeA = 0;
	if ( col == 0){
		bombeA = mine_autour_cg(tab2,lig,col);
	}
	else if (col == 9){
		bombeA = mine_autour_cd(tab2,lig,col);
	}
	else if (col != 0 && col != 9 && lig == 0){
		bombeA = mine_autour_chsc(tab2,lig,col);
	}
	else if (col != 0 && col != 9 && lig == 9){
		bombeA = mine_autour_cbsc(tab2,lig,col);
	}
	else {
		bombeA = mine_autour_sc(tab2,lig,col);
	}
	remplissage_case(tab,lig,col,bombeA);
}
 
void init(int tab[TAILLE][TAILLE] , int tabM[TAILLE][TAILLE]){
	remplir_tab(tab);
	remplir_tab(tabM);
	placer_bombe(tabM);
	mine_autour(tabM);
	printf("___________________L E  J E U  D U  D E M I N E U R___________________\n");
	affiche_plateau(tab);
	affiche_plateau(tabM);
}
 
int selection_ligne_par_utilisateur(){
    int i;
    printf("Entrez les coordonnées d'une case:\n");
    printf("La ligne: (0 et 9)\n");
    scanf("%d", &i);
    return i; 
}
 
int selection_colonne_par_utilisateur(){
int j;
printf("La colonne: (1 et 9)\n");
scanf("%d", &j);
return j;
}
 
void jeu(int tab[TAILLE][TAILLE] , int tabM[TAILLE][TAILLE]){
	int i,j,rep,verifrep,drap,comptmarqueur;
	drap = 0;
	comptmarqueur = 0;
	while(drap != 10){
		drap = 0;
		verifrep = 0;
		while(verifrep != 1){
			printf("1 . Découvrir une case.             2 . Placer un marqueur.\n");
			printf("3 . Enlever un marqueur. \n\n");
			scanf("%d",&rep);
			if(rep == 1){
				verifrep++;
				i = selection_ligne_par_utilisateur();
				j = selection_colonne_par_utilisateur();
				if ( tabM[i][j-1] == 'x'){
					printf("Vous avez découvert une bombe !!\n");
					printf("*************PERDU!!!***************\n");
			       	break;
				}
				else if ( tab[i][j-1] == 'F'){
					printf("Ce n'est pas possible de découvrir une case où se situe un marqueur.\n\n");
				}
				else{
					fonc_devoile(tab,tabM,i,j);
					affiche_plateau(tab);
					affiche_plateau(tabM);
				}
			}
			else if(rep == 2){
				verifrep++;
				if (comptmarqueur == 10){
					printf("Vous avez déjà placé tous vos marqueurs sur la grille.\n\n");
				}
				else{
					i = selection_ligne_par_utilisateur();
					j = selection_colonne_par_utilisateur();
					tab[i][j-1] = 'F';
					affiche_plateau(tab);
					affiche_plateau(tabM);
					comptmarqueur++;
					printf("Vous avez placé un marqueur à la case [%d,%d]\n\n",i,j);
					}
				}
			else if(rep == 3){
				verifrep++;
				if (comptmarqueur == 0){
					printf("Il n'y a actuellement pas de marqueur à enlever sur la grille.\n\n");
				}
				else{
					i = selection_ligne_par_utilisateur();
					j = selection_colonne_par_utilisateur();
					tab[i][j-1] = ' ';
					affiche_plateau(tab);
					affiche_plateau(tabM);
					comptmarqueur--;
					printf("Vous avez enlevé le marqueur se situant sur la case [%d,%d]\n\n",i,j);
				}
			}
		}
		for(int i = 0;i<TAILLE;i++){
			for(int j=0;j<TAILLE;j++){
				if(tab[i][j] == 'F' && tabM[i][j] == 'x'){
					drap++;
				}
			}
		}
	}
	printf("Félicitations ! Vous avez trouvé toutes les bombes !\n");
}
 
int main(){
	srand(time(NULL));
	int tab[TAILLE][TAILLE], tabM[TAILLE][TAILLE];
	int rep, verifrep;
	verifrep = 0;
	init(tab,tabM);
	while(verifrep != 1){
		printf("1 . Commencer la partie.             2 . Lire les règles.\n\n");
		scanf("%d",&rep);
		if(rep == 1){
			jeu(tab,tabM);
			verifrep++;
		}
		else if(rep == 2){
			printf("Le but du démineur est simple. \nIl faut découvrir toutes les cases libres sans faire exploser les mines présentes sur la grille. \nVous aurez la possibilité de poser autant de marqueurs qu'il y a de bombes sur la grille. \nLorsque tous vos marqueurs posés seront sur une bombe, la partie sera finie et vous aurez gagné ! \nMais attention, si vous découvrez une bombe, c'est GAME OVER. \nBonne chance.\n\n");
		}
	}
	return 0;
}

avec une fonction récursive

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
void dévoiler case(x, y)
{
  if (case est masquée et vide)
  {
   if (case haut gauche est valide et pas encore dévoilée)
      dévoiler case haut gauche (x-1, y-1) ?
   if (case haut est valide)
      dévoiler case haut (x, y-1) ?
   ... continuer pour les 8 cases autour de celle choisie
  }
}

01/06/2022, 17h08
rellik_nesquik

Je comprends le déroulé, or je ne comprends pas le "void dévoiler case(x,y)". Je n'ai jamais vu ce schéma en TD d'informatique, mes procédures étudiées étaient toujours dans la forme " void "nomprocédure" ( int ..., int ...., ...) ".
Pouvez-vous m'aiguiller davantage sur cette procédure ?
01/06/2022, 18h03
Xelland
Citation:

Envoyé par rellik_nesquik

Je comprends le déroulé, or je ne comprends pas le "void dévoiler case(x,y)". Je n'ai jamais vu ce schéma en TD d'informatique, mes procédures étudiées étaient toujours dans la forme " void "nomprocédure" ( int ..., int ...., ...) ".
Pouvez-vous m'aiguiller davantage sur cette procédure ?

Bousk a oublié le "_", la fonction doit s'appeler devoiler_case (x, y)

une remarque sur ce bout de code :
Code:

1 2 3 4 5 void placer_bombe(int tab[TAILLE][TAILLE]){ int col,lig,c,d; for(int i = 0; i < 10; i++){ col = rand()%9; lig = rand()%9;
il se passe quoi si tu modifies la valeur de TAILLE ? (en la diminuant par exemple ?)
et tu as le même problème ailleurs

Citation:

Il doit fonctionner avec le terminal donc pas de bibliothèque graphique.

on s'en fiche, le code du démineur ne change pas
si tu as bien codé, tu as une partie pour le "moteur" du démineur et une partie pour l'affichage (texte ou graphique)
01/06/2022, 18h12
rellik_nesquik

Citation:

Envoyé par Xelland

il se passe quoi si tu modifies la valeur de TAILLE ? (en la diminuant par exemple ?)
et tu as le même problème ailleurs

Merci pour ta réponse !

Si je modifie la valeur de TAILLE, mon code ne marchera pas oui je le sais bien, c'est pour cela qu'il est encore brouillon.. il serait plus judicieux de mettre " col = rand()%TAILLE " et cela pour tout mon code mais je le ferai lorsque j'aurai fini la procédure que je cherche à coder.

Sinon concernant la procédure que Bousk m'a indiqué, elle va juste vérifier que la case entrée en paramètre est vide non ? Il faudrait qu'elle remplisse directement le tableau or pour cela il faudrait ajouter d'autres paramètres que (x,y). Je suis confus.

Récursif agressif ?

Bonjour Bousk,
Citation:
Envoyé par Bousk
avec une fonction récursive
Code:

1 2 3 4 5 6 7 8 void devoiler_case(x, y) { if (case_(x, y) est masquée et vide) { if (case_[x-1, y-1] haut gauche est valide et masquée) devoiler_case(x-1, y-1) ? if (case_[x, y-1] haut est valide et masquée) devoiler_case(x, y-1) ? ... continuer pour les 8 cases autour de celle choisie } }
Sauf erreur de ma part, la récursivité va révéler tout le tableau des cases vides (sauf si on commence dans une zone cernée même en diagonale par des mines). C'est une variante de l'algorithme de remplissage d'une zone de dessin.

Salut

01/06/2022, 18h43
Bousk

Bousk il a surtout fourni du pseudo-code parce qu'il va pas faire ton projet à ta place, fournir toutes les structures et toute la logique pour gérer ces structures. :weird:
Donc non je n'ai pas oublié de _, dévoiler n'est pas non plus un nom de fonction valide à cause de l'accent et (x,y) me semblait être la norme pour représenter des coordonnées depuis... le collège ? :weird:
Et si tu estimes qu'il te faut un paramètre de plus à la méthode, par exemple le tableau de jeu à modifier, tu es libre d'adapter le code et non de te contenter de copier-coller ce que tu trouves sur internet. :calim2:

Que ton principal problème c'est sans doute que tu te jettes sur du code sans savoir ce que tu fais. Ce problème se résoud en 5mn avec un simple crayon pour dessiner sur une feuille quadrillée.
Tu dessines ton truc, te rends compte qu'il te faut 2 dimensions et que chaque case est un état qui peut se représenter avec un enum, puis tu sais que les cases sont dévoilées ou non donc un couple (dévoilée ou non, type réel de la case). Voire (cachée/dévoilée/flagged, type réel) si tu supportes de pouvoir mettre un drapeau sur une case comme dans le célèbre jeu de Windows.
Ensuite tu fais en sorte de pouvoir l'afficher, histoire de pouvoir suivre ce qu'il se passe.
Puis tu reprends 5mn pour faire tes scénarios
- je choisis cette case, ho c'est une bombe, boom game over
- je choisis cette case, cool elle est vide, je veux aussi dévoiler les cases vides autour
-- je prends une case autour, cool elle est vide, je veux aussi dévoiler les cases vides autour
--> ho ho, on serait pas dans une récursion ? :whistle:
-- je prends une case autour, oh c'est pas vide, j'en fais rien
- je choisis de mettre un drapeau sur cette case
- ...
Et ton exercice est plié en 2h chrono.

Citation:

Envoyé par Guesset

Sauf erreur de ma part, la récursivité va révéler tout le tableau des cases vides (sauf si on commence dans une zone cernée même en diagonale par des mines). C'est une variante de l'algorithme de remplissage d'une zone de dessin.

Exact, problème qui serait révélé au premier test et donc on améliore l'algorithme en mettant une limite à la récursivité, et on va sans doute pas taper sur les diagonales non plus mais juste les 4 directions.
Ou alors ne pas faire de récursivité du tout et juste vérifier les 4 cases autour. Et ça devient juste 4 if.
J'ai pas joué au démineur depuis bien 15 ans excusez-moi de ne plus en connaître tous les détails. :roll:

bizarre ton algo @Bousk :koi:
J'ai presque envie de voir le code des vieilles calculatrices (HP48G, TI92 par exemple) parce que sans la récursivité, je ne vois pas :oops:

En code algo, je vois cela

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void tester_et_devoiler(x, y) {
    si ((x, y) est cachée) alors
        nb_bombes = calcul_bombes_autour(x, y)
 
        si (nb_bombes == 0) alors
            devoiler(x, y) // on change d'état "dévoilée" et on affiche 1 case vide
 
            si ((x > 0) et (y > 0)) alors tester_et_devoiler(x-1, y-1) fsi // haut gauche
            si (x > 0) alors tester_et_devoiler(x-1, y) fsi // haut milieu
            si ((x > 0) et (y < (nb_cols-1))) alors tester_et_devoiler(x-1, y+1) fsi // haut droit
            si (y > 0) alors  tester_et_devoiler(x, y-1) fsi // gauche
            si (y < (nb_cols-1)) alors  tester_et_devoiler(x, y+1) fsi // droite
            si ((x < (nb_lignes-1)) et (y > 0)) alors tester_et_devoiler(x+1, y-1) fsi // bas gauche
            si (x < (nb_lignes-1)) alors tester_et_devoiler(x+1, y) fsi // bas milieu
            si ((x < (nb_lignes-1)) et (y < (nb_cols-1))) alors tester_et_devoiler(x+1, y+1) fsi // bas droit
        sinon
            devoiler_et_afficher(x, y, nb_bombes) // on change d'état "dévoilée" et on affiche 1 case avec le nombre de bombes
        fsi
    fsi
}

En théorie, on n'a pas besoin de tester si la case cachée contient 1 bombe ou pas, parce que ce test doit être fait lors du clic sur 1 case.

Édit : @Xelland :kiss:

01/06/2022, 20h48
Xelland

@foetus : je ferais le calcul des bombes autour, à l'initialisation une fois les bombes positionnées
ainsi, le choix de la case revient à modifier le contenu du tableau, puis un affichage une fois qu'il a été mis à jour (pour l'affichage, ça dépend si tu veux que ça se découvre petit à petit - donc mettre une temporisation - ou d'un coup)

dans ta fonction récursive, il te manque la gestion des bornes
02/06/2022, 10h00
Sve@r

Bonjour

Citation:

Envoyé par Bousk

Ou alors ne pas faire de récursivité du tout et juste vérifier les 4 cases autour. Et ça devient juste 4 if.
J'ai pas joué au démineur depuis bien 15 ans excusez-moi de ne plus en connaître tous les détails. :roll:

Quand tu cliques sur une case contenant 0 bombe, les 8 cases qui l'entourent s'ouvrent automatiquement. Et pour chacune de ces 8 cases ouvertes, chaque case qui contient elle-aussi 0 bombe ouvre alors les 8 cases qui entourent cette case et etc etc. Donc récursivité obligatoire et recherche dans les diagonales aussi.

Et (accessoirement) si tu as une case contenant (par exemple) 2 bombes et que tu as placé ces deux bombes, tu peux alors faire "shift+clic" (ou ctrl-clic je ne me souviens plus) sur la case à priori connue et toutes les autres cases non ouvertes situées autour s'ouvrent automatiquement et ça repart sur l'algo récursif.
02/06/2022, 12h25
Guesset

Bonjour,

La récursivité n'est jamais obligatoire mais elle est ici utile.

Je conseillerais d'utiliser un algorithme de remplissage ligne (si les 45° sont exclus).

Salutations
07/06/2022, 16h22
Médinoc
Je me suis déjà heurté à ce problème, et la récursivité fait plus de mal que de bien.
Pour un code facile à comprendre et maintenir, une approche itérative peut mieux marcher. Si l'utilisateur révèle une case vide, il faut:
1. Révéler la case, la marquer comme révélée.
2. En boucle:
  1. Initialiser flag "au moins une case a été révélée" à FAUX
  2. Parcourir la grille, pour chaque case:
    
    Si la case n'est pas révélée ET qu'elle est à côté d'au moins une case vide révélée, on la révèle et on passe le flag "au moins une case a été révélée" à VRAI
  3. Quitter la boucle si le flag "au moins une case a été révélée" est toujours FAUX
3. Mettre à jour l'affichage.
07/06/2022, 17h15
Médinoc

Oups, corrigé.