Discussion :

[Ifaktos]

Bonjour/bonsoir à tous,

Dans le cadre d'un projet, j'ai dû programmer un démineur en Pascal. Pour ce faire, j'ai choisi d'utiliser un tableau dynamique. Mon problème est le suivant : dans le démineur, lorsqu'une case qui n'est pas minée est collée à une case minée, celle-ci va prendre une valeur de 1 à 8 suivant le nombre de mines. J'ai donc essayé de faire une procédure ; cependant, celle-ci aurait un problème lors de l’exécution : en effet, elle fait apparaître une runtime error 216. J'ai cru comprendre que cela était dù au fait que la procédure s'effectuait hors du tableau ; malgré cela, je n'arrive pas à régler le problème, voici le code source.

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
 Program Demineur ;
 
Uses
crt;
 
Type coord = record cacher,drapeau,bombe:boolean; cases:word; End;
Type plateau = array of array of coord ;
 
///////////
// Debug //
///////////
 
Procedure bug(i:byte);
Begin
Write('BUG', i);
End;
 
//////////////////////////
// Fonction Initialiser //
//////////////////////////
 
Procedure Initialiser(var p:plateau);
 
Var
i,j:word;
Begin
	For i:=0 to length(p)-1 do
		Begin
			For j:=0 to length(p[0])-1 do
				Begin
				p[i,j].cacher:=True ;
				p[i,j].cases:=0;
				End;
		End;
End;
 
////////////////////////////////////////
// Fonction Afficher la grille du jeu //
////////////////////////////////////////
 
Procedure AfficheJeu(p:plateau);
 
Var
i,j:word;
Begin
 
	For i:=0 to length(p)-1 do
		Write('+---');
		Writeln('+');
	For i:=0 to length(p)-1 do
	Begin		
		For j:=0 to length(p[0])-1 do
			Begin
			If p[i,j].cacher then write('| # ')
			Else
				If ((p[i,j].cases)in[1..8])then write('| ', p[i,j].cases,' ')
				Else
					If (p[i,j].cases=0) then write('| 0 ')
					Else 
						If p[i,j].drapeau then write('| D ')
						Else
							Write('| M ');
			End;
			Writeln('|');
			For j:=0 to length(p)-1 do
    				Write('+---');
				Writeln('+');
	End;
End;
 
///////////////////////////////
// Fonction placer les mines //
///////////////////////////////
 
Procedure Placement(var p:plateau; k:integer);
 
Var 
i,r1,r2:word;
 
Begin
	i:=k;
	Randomize;
	While i>0 do
	Begin
		r1:=random(length(p)-1);
		r2:=random(length(p[0])-1);
		If(p[r1,r2].bombe=false) then // lorsqu'une "cases" est égale à 9, cela correspond à une bombe
		Begin
			p[r1,r2].bombe:=true;
			i:=i-1;
		End;
	End;
End;
 
///////////////////////////////////////
// Calculer le nombre de mine autour //
///////////////////////////////////////
 
Procedure chiffreCase(var p:plateau);
Var
i,j,k,l:word;
Begin
	For i:=0 to length(p)-1 do
	Begin
		For j:=0 to length(p[0])-1 do
		Begin
			If p[i,j].cases in [1..8] then
			Begin
				For k:=i-1 to i+1 do
				Begin
					For l:=j-1 to j+1 do
					Begin
						If (k>0) and (k<length(p)) and (l>0) and (l<length(p[0])) then
						Begin
							If not(p[k,l].bombe=true) then
							Begin
								p[k,l].cases:=p[k,l].cases+1;
							End;
						End;
					End;
				End;
			End;
		End;
	End;
End;
 
 
////////////////////////////////
// Fonction dévoiler une case //
////////////////////////////////
 
Procedure Devoiler(var pl:plateau; i,j:word);
 
Var
i1,j1:word;
 
Begin	
	pl[i,j].cacher:=false;
	bug(12);
	For i1:=i-1 to i+1 do
	Begin
		bug(13);
		For j1:=j-1 to j+1 do
		Begin
			bug(14);
			If (pl[i1,j1].cacher=true) then
			Begin
				bug(15);
				If pl[i1,j1].cases=0 then
					Devoiler(pl,i1,j1)
				Else
					bug(16);
					If pl[i1,j1].cases in [1..8] then
						pl[i,j].cacher:=false;
			End;
		End;
	End;
End;
 
///////////////////////////////
// Fonction poser un drapeau //
///////////////////////////////
 
Procedure Drap(var pl:plateau;i,j:word);
Begin
	pl[i,j].cacher:=false;
	pl[i,j].drapeau:=true;
End;
 
////////////////////////////////////////////////////////////////
// Fonction calculer le nombre de case qu'il reste à devoiler //
////////////////////////////////////////////////////////////////
 
Function Reste(p:plateau;m:integer):integer;
 
Var
i,j:word;
k:integer;
Begin
	k:=m*m;
	For i:=1 to m do
	Begin
		For j:=1 to m do
		Begin
			If not(p[i,j].cacher) then
				k:=k-1;
		End;
	End;
	Reste:=k;	
End;
 
/////////////////////////////////
// Fonction pour pouvoir jouer //
/////////////////////////////////
 
Procedure Jouer(var p:plateau;m:integer);
 
Var
i,j,c:word;
Resultat:boolean;
Begin
	Repeat
		Repeat
			Writeln('Choisissez les coordonnées où vous voulez jouer.');
			Write('Ligne : ');
			Readln(i);
			Write('Colonne : ');
			Readln(j);
		Until(p[i,j].cacher);
		Resultat:=false;
		Writeln('Que voulez-vous faire ?');
		Writeln('1) Dévoilez la case.');
		Writeln('2) Mettre un drapeau.');
		Readln(c);
		If (c=1) then
			Begin
				bug(8);
				If p[i,j].bombe=true then
				Begin
					bug(9);
					p[i,j].cacher:=false;
					Resultat:=True;
				End
				Else
					bug(10);
					If (p[i,j].cases) in [1..8] then
					Begin
						bug(11);
						p[i,j].cacher:=false;
					End
					Else
						Begin
						bug(20);
						Devoiler(p,i,j);
						End;
 
				If not(Resultat) then Resultat:=Reste(p,m)=m;
				clrscr;
				AfficheJeu(p);
			End;
		If (c=2) then
			Begin
				Drap(p,i,j);
				clrscr;
				AfficheJeu(p);
			End;
	Until(Resultat);
End;
 
/////////////////////////
// Programme principal //
/////////////////////////
 
Var 	
p:plateau;
i,j,m:word;
c:integer;
Begin
 
	Writeln('Bonjour, que voulez vous faire.');
	Writeln('1)Jouer au démineur mode débutant.');
	Writeln('2)Jouer au démineur mode intermédiaire.');
	Writeln('3)Jouer au démineur mode expert.');
	Writeln('4)Jouer au démineur mode éditable.');
	Readln(c);
	Begin
		If c=1 then
			setlength(p,8,8)
		Else
		Begin
			If c=2 then
				setlength(p,16,16)
			Else
			Begin
				If c=3 then
					setlength(p,24,24)
				Else
				Begin
					If c=4 then
					Begin
						Writeln('Choisissez les dimensions de votre tableau.(Ligne puis colonne.)');
						Readln(i);
						Readln(j);
						Setlength(p,i,j);
					End;
				End;
			End;
		End;
	End;
	Writeln('ça va ?'); // tout les writeln suivant m'avaient servie à trouver l'origine du runtime error
	Initialiser(p);
	Writeln('choisir nb mine');
	Readln(m);
	Placement(p,m);
	Writeln('ok');
	ChiffreCase(p);
	Writeln('D''acc');
	AfficheJeu(p);
	Writeln('Bye');
	Jouer(p,m);
	Writeln('Tchu');
	Readkey;
End.

L'erreur semble etre à la procedure ligne 100.

j'ai tenté de faire une autre procédure qui est la suivante, mais elle ne marche pas non plus :

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
////////////////////////////////////////////////
// Fonction calculer le nombre de mine autour //
////////////////////////////////////////////////
 
Function NbMineAutour(p:plateau; i,j:integer):word;
 
Var
n,i1,j1:word;
 
Begin
	n:=0;
		For i1:=i-1 to i+1 do
			Begin
				For j1:=j-1 to j+1 do
					If (p[i1,j1].bombe=true) then
						n:=n+1;
			End;
		NbMineAutour:=n;
End;
 
////////////////////////////////////////////////
// Fonction afficher le nombre de mine autour //
////////////////////////////////////////////////
 
Procedure AfficheNb( var p:plateau; m:integer);
 
Var
i1,j1:word;
Begin
	bug(11);
	For i1:=0 to length(p)-1 do
	Begin
		bug(12);
		For j1:=0 to length(p[0])-1 do
		Begin
			bug(13);
			If (p[i1,j1].bombe=false) then p[i1,j1].cases:=NbMineAutour(p,i1,j1);
		End;
	End;
End;

Edit : Fausse manip, j'avais posté sans une partie de mon message, désolé.

[Roland Chastain]

Bonjour !

Voici deux ou trois choses que j'ai relevées.

Dans la procédure Dévoiler(), il y a cette ligne :

Code :

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

If (pl[i1,j1].cacher=true) then

Certaines valeurs de i1 et de j1 seront en dehors des limites. Il faut donc les vérifier (comme tu l'as d'ailleurs fait dans la procédure précédente pour les valeurs de k et de l).

Juste après, la procédure s'appelle elle-même avec ces valeurs douteuses :

Code :

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

Devoiler(pl,i1,j1)

Du coup une erreur est amenée à se produire dès la première ligne :

Code :

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

pl[i,j].cacher:=false;

Autre problème, dans la fonction Reste(). Les coordonnées varient de 1 au nombre de mines !

Code :

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

For i:=1 to m do

Là tu étais fatigué, ou alors c'est moi.

Je n'ai pas compris non plus à quoi sert le nombre de mines élevé au carré.

Code :

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

k:=m*m;

Une dernière observation. Dans la procédure ChiffreCase(), tu as donc eu soin de vérifier les valeurs de k et l :

Code :

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

If (k>0) and (k<length(p)) and (l>0) and (l<length(p[0])) then

Mais il me semble qu'il faut conserver la valeur 0.

[Roland Chastain]

Dans la procédure ChiffreCase(), cette condition est à supprimer, autrement les chiffres resteront toujours à zéro :

Code :

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

If p[i,j].cases in [1..8] then

Il y a d'autres petites erreurs ici et là. Je te conseillerais de réécrire correctement toutes les expressions booléennes, ce qui te permettrait de trouver les erreurs en question.

Par exemple, au lieu d'écrire if not (bombe = true) (qui est inutilement compliqué), il suffit d'écrire if not bombe.

Bon courage !

[Ifaktos]

Oui, pour la procedure reste je devais être fatigué, et merci pour ton aide, je vais essayer de regler ces problème, merci pour ton aide.

Edit: pour la procédure dévoiler , ce que je voulais faire en appelant la procédure elle même c'était que si la case n'a pas de mine autour d'elle, elle va "repousser" cette action de devoiler, en effet au démineur, quand une case n'est pas coller à une case miné, elle n'affiche aucun nombre et ce devoilement est repoussé.

[Roland Chastain]

je vais essayer de régler ces problèmes

Je ne te sens pas très convaincu.

Tu as vu où était l'erreur ou pas ? Peut-être n'ai-je pas su bien l'expliquer. Ton programme n'est pas mal du tout. Il y a juste quelques petites corrections à faire pour qu'il fonctionne comme il faut.

On voit bien l'erreur dans le deuxième morceau de code que tu as posté. Dans la procédure AfficheNb(), i1 et j1 varient de 0 à 7 (pour un tableau de 8 sur 8). Dans la fonction NbMineAutour(), tu fais le tour de la case : tu vas forcément sortir du tableau lorsque la case en question est sur le bord. Donc il faut insérer un test supplémentaire :

Code :

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

1
2
3
4
 
For j1:=j-1 to j+1 do
  If (i1 >= 0) and (i1 < Length(p)) and (j1 >= 0) and (j1 < Length(p[0])) then // <--
    If (p[i1,j1].bombe=true) then

Pour la fonction Reste(), il n'est pas nécessaire (me semble-t-il) de passer le nombre de mines en paramètre. La fonction ne fait que compter le nombre de cases encore couvertes. C'est le résultat de la fonction qui sera comparé au nombre de mines.

Personnellement, j'écrirais la fonction comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
function Reste(p: plateau): integer;
var
  i, j, k: word;
begin
  k := 0;
  for i := 0 to Length(p) - 1 do
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].cacher then
        k := k + 1;
  Reste := k;
end;

Et je l'appellerais ainsi dans la procédure Jouer() :

Code :

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

resultat := (Reste(p) = m);

[Ifaktos]

Ah oui pour la fonction reste, ça semble peut-être plus logique de faire comme ça ! =)

Je t'avoues que je n'avais pas vraiment compris où était l'erreur. J'ai editer mon message si ça peut t'aider à me comprendre. Ou alors c'est vraiment une erreur que j'ai fais d'où le fait que tu ne comprennes pas x).

Sinon pour la condition à supprimer, oui j'avais compris mon erreur, c'est d'ailleur normale quand on y réfléchi ^^

Pour la deuxième partie de code, j'ai essayer de remplacer la procédure chiffreCase par ces deux procédure, mais ej ne sais pas ( une fois corriger) qu'elle serait la/les procédure la plus approprier.

Edit : Excuse moi si des fois je ne comprend pas des trucs assez simple, je débute dans l'informatique et j'ai pas mal de difficultés :/

[Roland Chastain]

pour la procédure dévoiler, ce que je voulais faire en appelant la procédure elle-même c'était que si la case n'a pas de mine autour d'elle, elle va "repousser" cette action de dévoiler

Là-dessus, nous sommes d'accord. Le problème, c'est qu'à l'intérieur de la fonction tu testes la valeur de cases qui n'existent pas.

Code :

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

For i1:=i-1 to i+1 do // quand i vaut 0, quelle est la première valeur que prend i1 ?

Code :

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

If (pl[i1,j1].cacher=true) then // et par conséquent qu'arrive-t-il ici ?

Essaie de corriger ton code, et poste la nouvelle version. On fera le point à ce moment-là, si tu veux bien.

[Ifaktos]

Alors j'ai fais quelques modification, je ne rencontre maintenant plus du tout de runtime error 216, cependant j'ai d'autre soucis..
Quand je rencontre une case vide elle ne "repousse" pas la fonction dévoiler, de plus les cases bombe n'ont pas l'air d'exister x), car quand je tombe sur un chiffre il n'y a pas de bombe autour.
Enfin la procédure "Reste" semble avoir un problème, ou alors c'est dans la procédure Jouer quand j'utilise la procédure Reste, En effet je ne peux jouer que 8 coup au maximum ( peut être plus, mais sur les essaie que j'ai fait, j'ai jouer au maximum 8 fois) et des fois je ne joue que 2~4 coups..

J'ai essayer de corriger en suivant tes pistes cependant je me perdais la pluspart du temps ( je suis sur projet depuis un moment, à force je fatigue vraiment beaucoup et je fais beaucoup d'erreur d'inattetion! :s)

Voilà sur quoi je me ramène

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
Program Demineur ;
 
Uses
crt;
 
Type coord = record cacher,drapeau,bombe:boolean; cases:word; End;
Type plateau = array of array of coord ;
 
///////////
// Debug //
///////////
 
Procedure bug(i:byte);
Begin
Write('BUG', i);
End;
 
//////////////////////////
// Fonction Initialiser //
//////////////////////////
 
Procedure Initialiser(var p:plateau);
 
Var
i,j:word;
Begin
	For i:=0 to length(p)-1 do
		Begin
			For j:=0 to length(p[0])-1 do
				Begin
				p[i,j].cacher:=True ;
				p[i,j].cases:=0;
				End;
		End;
End;
 
////////////////////////////////////////
// Fonction Afficher la grille du jeu //
////////////////////////////////////////
 
Procedure AfficheJeu(p:plateau);
 
Var
i,j:word;
Begin
 
	For i:=0 to length(p)-1 do
		Write('+---');
		Writeln('+');
	For i:=0 to length(p)-1 do
	Begin		
		For j:=0 to length(p[0])-1 do
			Begin
			If p[i,j].cacher then write('| # ')
			Else
				If ((p[i,j].cases)in[1..8])then write('| ', p[i,j].cases,' ')
				Else
					If (p[i,j].cases=0) then write('|   ')
					Else 
						If p[i,j].drapeau then write('| D ')
						Else
							If p[i,j].bombe then Write('| M ');
			End;
			Writeln('|');
			For j:=0 to length(p)-1 do
    				Write('+---');
				Writeln('+');
	End;
End;
 
///////////////////////////////
// Fonction placer les mines //
///////////////////////////////
 
Procedure Placement(var p:plateau; k:integer);
 
Var 
i,r1,r2:word;
 
Begin
	i:=k;
	Randomize;
	While i>0 do
	Begin
		r1:=random(length(p)-1);
		r2:=random(length(p[0])-1);
		If(p[r1,r2].bombe=false) then
		Begin
			p[r1,r2].bombe:=true;
			i:=i-1;
		End;
	End;
End;
 
///////////////////////////////////////
// Calculer le nombre de mine autour //
///////////////////////////////////////
 
Procedure chiffreCase(var p:plateau);
Var
i,j,k,l:word;
Begin
	For i:=0 to length(p)-1 do
	Begin
		For j:=0 to length(p[0])-1 do
		Begin
			For k:=i-1 to i+1 do
			Begin
				For l:=j-1 to j+1 do
				Begin
					If (k>=0) and (k<=length(p)) and (l>=0) and (l<=length(p[0])) then
					Begin
						If p[i,j].bombe then //Au départ je voulais mettre ici la case p[k,l] et sur la case que je traite après mettre p[i,j] mais ça me mene à un runtime error 216 dans ce cas là
						Begin
							p[k,l].cases:=p[k,l].cases+1; // c'est ici que je voulais mettre p[i,j].
						End;
					End;
				End;
			End;
		End;
	End;
End;
 
 
////////////////////////////////
// Fonction dévoiler une case //
////////////////////////////////
 
Procedure Devoiler(var pl:plateau; i,j:word);
 
Var
i1,j1:word;
 
Begin	
	pl[i,j].cacher:=false;
		For i1:=i-1 to i+1 do
		Begin
			//bug(13);
			For j1:=j-1 to j+1 do
			Begin
				If (i1>=0) and (i1<=length(pl)) and (j1>=0) and (j1<=length(pl[0])) then // j'ai rajouter une condition d'arret si i=0 
				Begin
					If pl[i1,j1].cacher then
					Begin
						//bug(15);
						If pl[i1,j1].cases=0 then
							Devoiler(pl,i1,j1)
						Else
							//bug(16);
							If pl[i1,j1].cases in [1..8] then
								pl[i1,j1].cacher:=false;
					End;
				End;
			End;
		End;
End;
 
///////////////////////////////
// Fonction poser un drapeau //
///////////////////////////////
 
Procedure Drap(var pl:plateau;i,j:word);
Begin
	pl[i,j].cacher:=false;
	pl[i,j].drapeau:=true;
End;
 
////////////////////////////////////////////////////////////////
// Fonction calculer le nombre de case qu'il reste à devoiler //
////////////////////////////////////////////////////////////////
 
Function Reste(p:plateau):integer;
 
Var
i,j:word;
k:integer;
Begin
	k:=length(p)*length(p[0]); //J'avais essayer de mettre la procédure que tu avais poster, mais dans tout els cas ça ne marche pas.. :/ Je pense comprendre que l'erreur viendrais du fait que le k baisse à chaque fois que je joue en retestant toute les cases.. alors qu'il faudrait juste qu'il retire le nombre de case découvert en plus et qu'il ne reparte pas à 0
	For i:=0 to length(p)-1 do
		For j:=0 to length(p[0])-1 do
			If not(p[i,j].cacher) then
				k:=k-1;
	Reste:=k;	
End;
 
/////////////////////////////////
// Fonction pour pouvoir jouer //
/////////////////////////////////
 
Procedure Jouer(var p:plateau;m:integer);
 
Var
i,j,c:word;
Resultat:boolean;
Begin
	Repeat
		Repeat
			Writeln('Choisissez les coordonnées où vous voulez jouer.');
			Write('Ligne : ');
			Readln(i);
			Write('Colonne : ');
			Readln(j);
		Until(p[i,j].cacher);
		Resultat:=false;
		Writeln('Que voulez-vous faire ?');
		Writeln('1) Dévoilez la case.');
		Writeln('2) Mettre un drapeau.');
		Readln(c);
		If (c=1) then
			Begin
				bug(8);
				If (p[i,j].bombe=true) then
				Begin
					bug(9);
					p[i,j].cacher:=false;
					Resultat:=True;
				End
				Else
					bug(10);
					If (p[i,j].cases) in [1..8] then
					Begin
						bug(11);
						p[i,j].cacher:=false;
					End
					Else
						Begin
							bug(20);
							Devoiler(p,i,j);
						End;
 
				If not(Resultat) then Resultat:=(Reste(p)=0);
				clrscr;
				AfficheJeu(p);
			End;
		If (c=2) then
			Begin
				Drap(p,i,j);
				clrscr;
				AfficheJeu(p);
			End;
	Until(Resultat);
End;
 
/////////////////////////
// Programme principal //
/////////////////////////
 
Var 	
p:plateau;
i,j,m:word;
c:integer;
Begin
 
	Writeln('Bonjour, que voulez vous faire.');
	Writeln('1)Jouer au démineur mode débutant.');
	Writeln('2)Jouer au démineur mode intermédiaire.');
	Writeln('3)Jouer au démineur mode expert.');
	Writeln('4)Jouer au démineur mode éditable.');
	Readln(c);
	Begin
		If c=1 then
			setlength(p,8,8)
		Else
		Begin
			If c=2 then
				setlength(p,16,16)
			Else
			Begin
				If c=3 then
					setlength(p,24,24)
				Else
				Begin
					If c=4 then
					Begin
						Writeln('Choisissez les dimensions de votre tableau.(Ligne puis colonne.)');
						Readln(i);
						Readln(j);
						Setlength(p,i,j);
					End;
				End;
			End;
		End;
	End;
	Writeln('ça va ?');
	Initialiser(p);
	Writeln('choisir nb mine');
	Readln(m);
	Placement(p,m);
	Writeln('ok');
	ChiffreCase(p);
	Writeln('D''acc');
	AfficheJeu(p);
	Writeln('Bye');
	Jouer(p,m);
	Writeln('Tchu');
	Readkey;
End.

[Roland Chastain]

Je n'ai pas encore tout relu, mais déjà dans la procédure ChiffreCase() tu t'es trompé sur le contrôle des valeurs de k et l. Elles doivent être supérieures ou égales à zéro et strictement inférieures à la longueur du tableau (autrement c'est en dehors puisqu'on compte à partir de 0).

Une fois cette correction faite, c'était bien ta première idée qui était la bonne (je parle de ce que tu as écrit en commentaire).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure ChiffreCase(var p: plateau);
var
  i, j: word;
  k, l: integer;
begin
  for i := 0 to Length(p) - 1 do
    for j := 0 to Length(p[0]) - 1 do
      for k := i - 1 to i + 1 do
        for l := j - 1 to j + 1 do
          if (k >= 0) and (k <{=} Length(p)) and (l >= 0) and (l <{=} Length(p[0])) then // <--
            if p[k, l].bombe then
              Inc(p[i, j].cases);
end;

Repose-toi un peu ! Rome ne s'est pas faite en un jour.

[Ifaktos]

Oui je vais faire un break un petit moment, mais enfaite le problème est que le projet est à rendre demain.. ( je sais que c'est pas très malin de demander de l'aide au dernier moment, mais j'avais déjà mis un long moment à coder tout ce que j'ai fais pour le moment et ce n'est que Lundi que j'ai eu des runtime error 216 et je voulais régler le soucis moi même au départ mais en vain.)

Merci infiniment de l'aide que tu m'apporte en tout cas. =) Je vais corriger l'inégalité stricte et reprendre le code un peu plus tard..

[Roland Chastain]

Voici une procédure qui pourrait t'aider. Elle te permet de visualiser l'état complet de ton tableau dans une boîte de message. De cette façon tu pourras mieux te rendre compte de ce qui marche et de ce qui ne marche pas.

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
procedure Controle(const p: plateau);
var
  i, j: integer;
  s: string;
begin
  s := 'CACHER' + #10;
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].cacher then
        s := s + '1'
      else
        s := s + '0';
    s := s + #10;
  end;
 
  s := s + #10 + 'DRAPEAU' + #10;
 
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].drapeau then
        s := s + '1'
      else
        s := s + '0';
    s := s + #10;
  end;
 
  s := s + #10 + 'BOMBE' + #10;
 
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].bombe then
        s := s + '1'
      else
        s := s + '0';
    s := s + #10;
  end;
 
  s := s + #10 + 'CASES' + #10;
 
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      s := s + IntToStr(p[i, j].cases);
    s := s + #10;
  end;
  MessageBox(0, pChar(s), 'Contr'#244'le', MB_OK);
end;

Tu peux l'appeler par exemple à la fin de la procédure AfficheJeu().

Code :

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

1
2
  Controle(p);
end;

Tu dois rajouter deux unités :

Code :

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

uses Crt, Windows, SysUtils;

Ah, j'oubliais, tu devras aussi ajouter cette directive de compilation :

Code :

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

1
2
program Demineur;
{$MODE DELPHI}

Merci infiniment de l'aide que tu m'apportes en tout cas.

Pas de quoi !

[Ifaktos]

Bonjour,

Alors j'ai essayer d’intégrer cette procédure à mon programme cependant lorsque je compile, j’ai un message d'erreur à la ligne où j'ai ajouter l'unité windows. "Can't find unit Windows used by Demineur" J'ai pourtant fais comme tu l'as indiqué.

Je dois avouer ne pas comprendre comment tu as coder cette procédure, je l'ai simplement copier coller dans mon programme, j'ai compris le principe cependant je ne vois pas du tout comment tu t'y es pris :s donc je ne sais pas d'où viendrais l'erreur..
J'ai bien ajouter les deux unité et le mode delphi, et je n'ai pas oublier d'appeller la procédure à la fin de AfficheJeu()

[Roland Chastain]

Bonjour !

Désolé, je ne voulais pas t'apporter des difficultés supplémentaires.

Laisse-moi un instant pour te bricoler une autre procédure du même genre (mais ne faisant pas appel à l'unité Windows).

P.-S. Voici ce que je te propose :

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
procedure Controle(const p: plateau);
var
  i, j: integer;
  s: string;
  t: text;
begin
  s := 'CACHER' + #10;
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].cacher then
        s := s + 'T '
      else
        s := s + 'F ';
    s := s + #10;
  end;
  s := s + #10 + 'DRAPEAU' + #10;
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].drapeau then
        s := s + 'T '
      else
        s := s + 'F ';
    s := s + #10;
  end;
  s := s + #10 + 'BOMBE' + #10;
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      if p[i, j].bombe then
        s := s + 'T '
      else
        s := s + 'F ';
    s := s + #10;
  end;
  s := s + #10 + 'CASES' + #10;
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
      s := s + IntToStr(p[i, j].cases) + ' ';
    s := s + #10;
  end;
  Assign(t, 'Debug.txt');
  Rewrite(t);
  Write(t, s);
  Close(t);
end;

Il faut déclarer l'unité SysUtils. Tu places l'appel de la procédure au même endroit que j'avais indiqué. De cette façon, à chaque affichage de ton tableau, un fichier texte nommé "Debug.txt" est créé dans le dossier où se trouve ton exécutable. Tu peux ouvrir ce fichier dans un éditeur de texte pour voir si tout se passe bien. Attention : à chaque appel, le contenu du fichier est écrasé.

Voici ce que ça donne chez moi :

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
CACHER
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
T T T T T T T T 
 
DRAPEAU
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
F F F F F F F F 
 
BOMBE
F F F T F F T F 
F F F F T F F T 
T F F T F F T T 
F F F F F F F F 
F F F F F F F T 
F F F F F F F T 
F F F F F F F F 
F F F F T F F T 
 
CASES
0 0 1 2 2 2 2 2 
1 1 2 3 3 3 4 4 
1 1 1 2 2 2 3 3 
1 1 1 1 1 1 3 3 
0 0 0 0 0 0 2 2 
0 0 0 0 0 0 2 2 
0 0 0 1 1 1 2 2 
0 0 0 1 1 1 1 1

[Ifaktos]

C'est bon ça marche aussi pour moi !

Alors il semble y avoir plusieurs soucis, déjà quand je tombe sur une bombe, la bombe s'affiche comme un chiffre, cela doit résoudre le "problème" de reste du coup, je pense que les autres fois je tombais simplement sur une bombe, mais comme celle-ci apparaissait comme un chiffre, je pensais que le programme se fermait à cause de la procédure reste, mais elle se fermait juste parce que je tombait sur une bombe mal représenté. Donc la procédure Reste doit fonctionner normalement.

Il faut donc que je règle encore le problème de cette bombe qui s'affiche d'une mauvaise manière.. Je ne pense pas que ce soit le plus dur à corriger, maintenant il faut que je fasse fonctionner cette procédure dévoiler, qui ne "repousse" pas quand je tombe sur une case vide, et j'aurais fais le tour.

Je te tiens au courant rapidement, merci de l'aide que tu m'apporte encore une fois, j'avais vraiment énormément de mal à résoudre tout mes petits soucis..

[Roland Chastain]

Alors il semble y avoir plusieurs soucis, déjà quand je tombe sur une bombe, la bombe s'affiche comme un chiffre

Effectivement, dans ta procédure AfficheJeu(), tu ne testes pas les choses dans le bon ordre.

L'ordre correct, me semble-t-il, est le suivant : La case est-elle cachée ? Si elle est cachée, y a-t-il un drapeau ou non ? Si elle n'est pas cachée, y a-t-il une bombe ou non ? S'il n'y a pas de bombe, y a-t-il un chiffre (un chiffre différent de 0) ?

Parallèlement, dans ta procédure Drap(), tu ne devrais pas modifier la valeur de la variable cacher. Le fait de mettre un drapeau n'implique pas qu'on dévoile le contenu de la case.

Enfin, dans ta procédure Initialise(), il serait plus correct d'initialiser toutes les variables :

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
procedure Initialiser(var p: plateau);
var
  i, j: word;
begin
  for i := 0 to Length(p) - 1 do
  begin
    for j := 0 to Length(p[0]) - 1 do
    begin
      p[i, j].cacher := true;
      p[i, j].drapeau := false;
      p[i, j].bombe := false;
      p[i, j].cases := 0;
    end;
  end;
end;

[Ifaktos]

J'ai modifier la procédure AfficheJeu() en suivant ton raisonnement et maintenant cela marche impeccablement ! Merci !

Il ne me reste donc plus que repousser les cases.

Edit : Il ne me reste plus que la procédure repousser les cases =).

[Roland Chastain]

Il ne me reste donc plus que repousser les cases.

Chez moi ça fonctionne, avec la dernière procédure que tu avais postée.

Il y avait juste à remplacer i1 <= Length par i1 < Length (idem pour j1) et à modifier le type de i1 et j1 : ce doit être integer, et non word, puisqu'à un moment les variables prennent la valeur -1.

[Ifaktos]

Ah oui effectivement...

Bon ba mon programme semble fonctionner totalement.

Merci encore pour toute l'aide que tu m'as apporté ! Je t'en suis infiniment reconnaissant !! Bonne journée à toi ! =)