[IA] Problème pour prévoir des coups en avance

Version imprimable

Bonjour à tous,
Je suis désolé de vous embêter encore une fois avec un problème sur le même sujet. J'ai "réussi" à programmer une Puissance 4 avec l'algorithme Minimax pour l'IA. L'ennuie c'est que quelque soit la profondeur choisie, l'IA joue très très mal : il suffit d'aligner trois pions les uns à côté des autres vers la colonne du milieu et c'est gagné. L'IA insiste pour jouer la colonne 0 jusqu'à ce qu'il y ait trois pions de l'adversaire aligné.
Est-ce que vous pouvez jeter un coup-d'oeil au code ?
N.B. : pour l'instant j'ai juste traduit l'algorithme qui était en pseudo-code, il est donc normal pour le moment que tout soit statique.

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
 
public class P4minimax{
 
	public static void main (String args[])
	{
		int[][] jeu = new int[6][7]; 
		int x, y; 
 
 
 
		while(gagnant(jeu)==0)
		{
			IA_jouer(jeu, 5); 
 
 
			for(int i=0; i<jeu.length; i++)
			{
				for(int j=0; j<jeu[0].length; j++)
				{
					if(jeu[i][j]==1 || jeu[i][j]==2)
					{
						System.out.print(jeu[i][j]+"	"); 
					}
					else
					{
						System.out.print(0+"	"); 
					}
				}
				System.out.println(); 
			}
			do{
				System.out.println("entrer x"); 
				x=Lire.i(); 
				System.out.println("entrer y"); 
				y=Lire.i(); 
			}while(jeu[x][y]!=0); 
			jeu[x][y]=2; 
		}
	}
 
 
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static void IA_jouer(int[][] jeu, int profondeur)
	{
		int max = -10000; 
		int temp, maxj=0; 
		int j; 
		for(j = 0; j<jeu[0].length; j++)
		{
			if(jeu[0][j]==0)
			{
				placer(jeu, j, 1); 
				temp = Min(jeu, profondeur - 1); 
				if(temp>max)
				{
					max = temp; 
					maxj = j; 
				}
				corriger(jeu, j); 
			}
		}
		placer(jeu, maxj, 1); 
	}
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static int Min(int[][] jeu, int profondeur)
	{
		if(profondeur==0 || gagnant(jeu)!=0)
		{
			return eval(jeu); 
		}
		int min = 10000; 
		int j, temp; 
 
		for(j = 0; j<jeu[0].length; j++)
		{
			if(jeu[0][j]==0)
			{
				placer(jeu, j, 1); 
				temp = Max(jeu, profondeur - 1); 
				if(temp<min)
				{
					min = temp; 
				}
				corriger(jeu, j); 
			}
		}
		return min; 
	}
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static int Max(int[][] jeu, int profondeur)
	{
		if(profondeur == 0 || gagnant(jeu)!=0)
		{
			return eval(jeu); 
		}
		int max = -10000; 
		int j, temp; 
 
		for(j = 0; j<jeu[0].length; j++)
		{
			if(jeu[0][j]==0)
			{
				placer(jeu, j, 2); 
				temp = Min(jeu, profondeur - 1); 
				if(temp>max || (temp==max && Math.random()%2==0))
				{
					max = temp; 
				}
				corriger(jeu, j); 
			}
		}
		return max; 
	}
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static int eval(int[][] jeu)
	{
		int vainqueur, nb_de_pions = 0; 
		int i, j; 
 
		for(i = 0; i<jeu.length; i++)
		{
			for(j = 0; j<jeu[0].length; j++)
			{
				if(jeu[i][j]!=0)
				{
					nb_de_pions++; 
				}
			}
		}
 
		vainqueur = gagnant(jeu); 
		if(vainqueur!=0)
		{
			if(vainqueur==1)
			{
				return 1000-nb_de_pions; 
			}
			else if(vainqueur==2)
			{
				return -1000+nb_de_pions; 
			}
		}
		return coupgagnant(jeu, 1)-coupgagnant(jeu, 2); 
	}
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static void placer(int[][] jeu, int j, int type)
	{
		int i = jeu.length - 1; 
		while(jeu[i][j]!=0 && i!=0)
		{
			i--; 
		}
		jeu[i][j]=type; 
	}
 
 
	private static void corriger(int[][] jeu, int j)
	{
		int i = 0; 
		while(jeu[i][j]==0 && i<jeu.length-1)
		{
			i++; 
		}
		jeu[i][j]=0; 
	}
 
	// ----------------------------------------------
	// ----------------------------------------------
 
	private static int coupgagnant(int[][] jeu, int type)
	{
		int j = 0; 
		int gagnant = 0; 
		int compteur = 0; 
		for(j = 0; j<jeu[0].length; j++)
		{
			if(jeu[0][j]==0)
			{
				placer(jeu, j, type); 
				gagnant = gagnant(jeu); 
				corriger(jeu, j); 
				if(gagnant!=0)
				{
					compteur++; 
				}
			}
		}
		return compteur; 
	}
 
	private static int colonne (int[][] jeu, int j, int type)
	{
		int b=0, k=0; 
		while(b<6 && k<4)
		{
			if(jeu[b][j]==type)
			{
				k=k+1;
			}
			else
			{
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int ligne (int[][] jeu, int i, int type)
	{
		int b=0, k=0;
		while(b<7 && k<4)
		{
			if(jeu[i][b]==type)
			{
				k=k+1;
			}
			else
			{
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int diagprinc (int[][] jeu, int i, int j, int type)
	{
		int b=0, k=0, min; 
		if(i<j)
		{
			min=i;
		}
		else
		{
			min=j;
		}
		while(i-min+b<6 && j-min+b<7 && k<4)
		{
			if(jeu[i-min+b][j-min+b]==type)
			{
				k=k+1;
			}
			else
			{
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int diagsecon (int[][] jeu, int i, int j, int type)
	{
		int b=0, k=0, min;
		if(i<6-j)
		{
			min=i;
		}
		else
		{
			min=6-j;
		}
		while(0<=i-min+b && i-min+b<6 && j+min-b<7 && j+min-b>=0 && k<4)
		{
			if(jeu[i-min+b][j+min-b]==type)
			{
				k=k+1;
			}
			else
			{
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	public static int gagnant(int[][] jeu)
	{
		int i = 0; 
		int j = 0; 
		int k = 0; 
		boolean fini = false; 
		int type = 0; 
		while(j<jeu[0].length && !fini)
		{
			i=0; 
			while(i<jeu.length && jeu[i][j]==0)
			{
				i++; 
			}
			if(i!=jeu.length)
			{
				type = jeu[i][j]; 
				if(colonne(jeu, j, type)<ligne(jeu, i, type))
				{
					k=ligne(jeu, i, type);
				}
				else
				{
					k=colonne(jeu, j, type);
				}
				if(k<diagprinc(jeu, i, j, type))
				{
					k=diagprinc(jeu, i, j, type);
				}
				if(k<diagsecon(jeu, i, j, type))
				{
					k=diagsecon(jeu, i, j, type);
				}
 
				if(k==4)
				{
					fini = true; 
				}
				else
				{
					i = 0; 
				}
			}
			else
			{
				i=0; 
			}
			j++; 
		}
		if(fini)
		{
			return jeu[i][j-1]; 
		}
		else
		{
			return 0; 
		}
	}
 
 
}

25/08/2014, 13h46
Invité

Est-ce que quelqu'un pourrait m'aider svp. Je réflechis toujours mais le code me semble bon !
25/08/2014, 17h02
Sennad

Salut,

Désolé je n'ai pas de notions en IA, cependant je vois que tu n’as toujours pas eu de réponse, tu pourrais rajouter dans le titre de ton poste "[IA]".
Ca amènera ceux qui savent faire, car la ton titre ne parle pas du tout :/

Bon courage

La logique de base pour la IA est là. Il n'y a pas de doute...
Cependant, le niveau de "propreté" de ton code est très faible. Celui-ci fonctionne, mais il est pratiquement impossible de savoir quel méthode fait quoi sans avoir à relire l'intégralité du code.

Voici quelques conseils de base :
Les variables à un seul caractère sont à éviter.
Écrire la javadoc des méthodes.

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
	public static void main(String args[]) {
		int[][] jeu = new int[6][7];
		int ligneJoueur, colonneJoueur;
		while (gagnant(jeu) == 0) {
			IA_jouer(jeu, 5);
			for (int ligne = 0; ligne < jeu.length; ligne++) {
				for (int colonne = 0; colonne < jeu[0].length; colonne++) {
					if (jeu[ligne][colonne] == 1 || jeu[ligne][colonne] == 2) {
						System.out.print(jeu[ligne][colonne] + "	");
					} else {
						System.out.print(0 + "	");
					}
				}
				System.out.println();
			}
			do {
				System.out.println("entrer x");
				ligneJoueur = Lire.i();
				System.out.println("entrer y");
				colonneJoueur = Lire.i();
			} while (jeu[ligneJoueur][colonneJoueur] != 0);
			jeu[ligneJoueur][colonneJoueur] = 2;
		}
	}

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
	/**
         * Calcul le score minimum pour le jeu et le nombre de coup donnée.
         * @param jeu L'instance de jeu utilisé pour le calcul.
         * @param profondeur La profondeur utilisé pour le calcul.
         * @return Le score minimum pour le jeu et le nombre de coup donnée
         */
	private static int Min(int[][] jeu, int profondeur) {
		if (profondeur == 0 || gagnant(jeu) != 0) {
			return eval(jeu);
		}
		int score = 10000;
		int colonne, scoreCourant;
 
		for (colonne = 0; colonne < jeu[0].length; colonne++) {
			if (jeu[0][colonne] == 0) {
				placer(jeu, colonne, 1);
				scoreCourant = Max(jeu, profondeur - 1);
				if (scoreCourant < score) {
					score = scoreCourant;
				}
				corriger(jeu, colonne);
			}
		}
		return score;
	}

Sur le denier exemple de code revue, je constate que la fonction Min appel la fonction Max. Cela qui me semble étrange.

De plus le passage du tableau de jeu à l'IA n'est pas une bonne idée. Cela te force a annuler tout les coups simuler par celle-ci. Il serai préférable de dupliquer l'instance de jeu, afin que le calcul de l'IA soit totalement décorrélé de l'instance de jeu.

Cordialement,
Patrick Kolodziejczyk.

27/08/2014, 22h13
Invité

J'ai suivi tes conseils : j'ai écrit la javadoc des méthodes (seulement pour l'IA, le reste est de toute façon temporaire, juste pour tester l'IA), j'ai amélioré le nom des variables, j'ai essayé d'améliorer la propreté du code et j'ai évité le passage du tableau de jeu.
Je ne comprend pas pourtant pourquoi la fonction Min ne dois pas appeler la fonction Max.
Et enfin le code ne fonctionne toujours pas. L'IA insiste pour jouer la première colonne sauf si j’aligne 3 jetons. Je ne vois vraiment pas où est le problème.

@Sennad : merci pour le conseil mais je ne sais pas comment changer le titre :/

Oups, voilà le code corrigé :

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
 
public class P4minimax2{
 
	public static void main (String args[])
	{
		int[][] jeu = new int[6][7]; 
		int ligneJoueur, colonneJoueur; 
		while (gagnant(jeu)==0) {
			IA_jouer(jeu, 5); 
			for (int ligne = 0; ligne < jeu.length; ligne++) {
				for (int colonne = 0; colonne < jeu[0].length; colonne++) {
					if (jeu[ligne][colonne] == 1 || jeu[ligne][colonne] == 2) {
						System.out.print(jeu[ligne][colonne]+"	"); 
					}
					else {
						System.out.print(0 + "	"); 
					}
				}
				System.out.println(); 
			}
			do {
				System.out.println("entrer x"); 
				ligneJoueur = Lire.i(); 
				System.out.println("entrer y"); 
				colonneJoueur = Lire.i(); 
			} while(jeu[ligneJoueur][colonneJoueur] != 0); 
			jeu[ligneJoueur][colonneJoueur] = 2; 
		}
	}
 
	/**
         * Calcul le meilleur mouvement pour le jeu. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @param profondeur La profondeur utilisé pour le calcul. 
         */
	private static void IA_jouer(int[][] jeu, int profondeur) {
		int score = -10000; 
		int scoreCourant, meilleurColonne = 0; 
		int colonne; 
		int[][] copie = new int[6][7]; 
		dupliquer(jeu, copie); 
		for (colonne = 0; colonne < copie[0].length; colonne++) {
			if (copie[0][colonne] == 0) {
				placer(copie, colonne, 1); 
				scoreCourant = Min(copie, profondeur - 1); 
				if (scoreCourant > score) {
					score = scoreCourant; 
					meilleurColonne = colonne; 
				}
				dupliquer(jeu, copie); 
			}
		}
		placer(jeu, meilleurColonne, 1); 
	}
 
 
	/**
         * Calcul le score minimum pour le jeu et le nombre de coup donnée. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @param profondeur La profondeur utilisé pour le calcul. 
         * @return Le score minimum pour le jeu et le nombre de coup donnée. 
         */
	private static int Min(int[][] jeu, int profondeur) {
		if (profondeur == 0 || gagnant(jeu) != 0) {
			return eval(jeu); 
		}
		int score = 10000; 
		int colonne, scoreCourant; 
		int[][] copie = new int[6][7]; 
		dupliquer(jeu, copie); 
 
		for (colonne = 0; colonne < copie[0].length; colonne++) {
			if (copie[0][colonne] == 0) {
				placer(copie, colonne, 1); 
				scoreCourant = Max(copie, profondeur - 1); 
				if (scoreCourant < score) {
					score = scoreCourant; 
				}
				dupliquer(jeu, copie); 
			}
		}
		return score; 
	}
 
	/**
         * Calcul le score maximum pour le jeu et le nombre de coup donnée. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @param profondeur La profondeur utilisé pour le calcul. 
         * @return Le score maximum pour le jeu et le nombre de coup donnée. 
         */	
	private static int Max(int[][] jeu, int profondeur) {
		if (profondeur == 0 || gagnant(jeu) != 0) {
			return eval(jeu); 
		}
		int score = -10000; 
		int colonne, scoreCourant; 
		int[][] copie = new int[6][7]; 
		for (colonne = 0; colonne < copie[0].length; colonne++) {
			if (copie[0][colonne]==0) {
				placer(copie, colonne, 2); 
				scoreCourant = Min(copie, profondeur - 1); 
				if (scoreCourant > score) {
					score = scoreCourant; 
				}
				dupliquer(jeu, copie); 
			}
		}
		return score; 
	}
 
	/**
         * Evalue la position du jeu. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @return La valeur associée à la position du jeu. 
         */
	private static int eval(int[][] jeu) {
		int vainqueur, nb_de_pions = 0; 
		int ligne, colonne; 
 
		for (ligne = 0; ligne < jeu.length; ligne++) {
			for (colonne = 0; colonne < jeu[0].length; colonne++) {
				if (jeu[ligne][colonne] != 0) {
					nb_de_pions++; 
				}
			}
		}
 
		vainqueur = gagnant(jeu); 
		if(vainqueur != 0) {
			if(vainqueur == 1) {
				return 1000-nb_de_pions; 
			}
			else if(vainqueur == 2) {
				return -1000+nb_de_pions; 
			}
		}
		return coupgagnant(jeu, 1)-coupgagnant(jeu, 2); 
	}
 
	/**
         * Place un jeton à la colonne demandée. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @param colonne La colonne qui reçoit le jeton. 
         * @param type Le joueur qui place le jeton. 
         */
	private static void placer (int[][] jeu, int colonne, int type) {
		int ligne = jeu.length - 1; 
		while (jeu[ligne][colonne] != 0 && ligne != 0) {
			ligne--; 
		}
		jeu[ligne][colonne]=type; 
	}
 
	/**
         * Vérifie si un joueur peut gagner en un coup. 
         * @param jeu L'instance de jeu utilisé pour le calcul. 
         * @param type Le joueur pour lequel on vérifie s'il peut gagner en un coup. 
         * @return Le nombre de coup qui permette au joueur de gagner. 
         */
	private static int coupgagnant(int[][] jeu, int type) {
		int j = 0; 
		int gagnant = 0; 
		int compteur = 0; 
		int[][] copie = new int[6][7]; 
		for (j = 0; j < copie[0].length; j++) {
			if (jeu[0][j]==0) {
				placer(copie, j, type); 
				gagnant = gagnant(copie); 
				dupliquer(jeu, copie); 
				if(gagnant!=0) {
					compteur++; 
				}
			}
		}
		return compteur; 
	}
 
	/**
         * Crée une copie de l'instance du jeu. 
         * @param jeu L'instance de jeu à copier. 
         * @param copie L'instance de jeu pour le calcul. 
         */
	private static void dupliquer (int[][] jeu, int[][] copie) {
		for (int ligne = 0; ligne < jeu.length; ligne++) {
			for (int colonne = 0; colonne < jeu[0].length; colonne++) {
				copie[ligne][colonne] = jeu[ligne][colonne]; 
			}
		}
	}
 
	//--------------------------------------------------
	//--------------------------------------------------
 
	private static int colonne (int[][] jeu, int j, int type) {
		int b=0, k=0; 
		while(b<6 && k<4) {
			if(jeu[b][j]==type) {
				k=k+1;
			}
			else {
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int ligne (int[][] jeu, int i, int type) {
		int b=0, k=0;
		while(b<7 && k<4) {
			if(jeu[i][b]==type) {
				k=k+1;
			}
			else {
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int diagprinc (int[][] jeu, int i, int j, int type) {
		int b=0, k=0, min; 
		if(i<j) {
			min=i;
		}
		else {
			min=j;
		}
		while(i-min+b<6 && j-min+b<7 && k<4) {
			if(jeu[i-min+b][j-min+b]==type) {
				k=k+1;
			}
			else {
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	private static int diagsecon (int[][] jeu, int i, int j, int type) {
		int b=0, k=0, min;
		if(i<6-j) {
			min=i;
		}
		else {
			min=6-j;
		}
		while(0<=i-min+b && i-min+b<6 && j+min-b<7 && j+min-b>=0 && k<4) {
			if(jeu[i-min+b][j+min-b]==type) {
				k=k+1;
			}
			else {
				k=0;
			}
			b=b+1;
		}
		return k;
	}
 
	public static int gagnant(int[][] jeu) {
		int i = 0; 
		int j = 0; 
		int k = 0; 
		boolean fini = false; 
		int type = 0; 
		while(j<jeu[0].length && !fini) {
			i=0; 
			while(i<jeu.length && jeu[i][j]==0) {
				i++; 
			}
			if(i!=jeu.length) {
				type = jeu[i][j]; 
				if(colonne(jeu, j, type)<ligne(jeu, i, type)) {
					k=ligne(jeu, i, type);
				}
				else {
					k=colonne(jeu, j, type);
				}
				if(k<diagprinc(jeu, i, j, type)) {
					k=diagprinc(jeu, i, j, type);
				}
				if(k<diagsecon(jeu, i, j, type)) {
					k=diagsecon(jeu, i, j, type);
				}
 
				if(k==4) {
					fini = true; 
				}
				else {
					i = 0; 
				}
			}
			else {
				i=0; 
			}
			j++; 
		}
		if(fini) {
			return jeu[i][j-1]; 
		}
		else {
			return 0; 
		}
	}
 
}

28/08/2014, 10h06
Sennad

Salut,

Je pense qu'il faut que tu édite ton premier post, et dans Intitulé tu dois avoir le titre ;)
29/08/2014, 20h30
Invité

Le titre est OK (merci Robin56), mais je ne toujours pas de solution :/ Ça me parait pourtant correcte. Je dois avoir fait une erreur dans la fonction d'évaluation.
30/08/2014, 15h35
Invité

Après avoir longuement réfléchi, j'en viens la conclusion que ma fonction heuristique est particulièrement mauvaise. J'ai un peu cherché sur le net mais je n'ai pas rencontré de fonction heuristique bien fait. Du coup si quelqu'un a une proposition, je suis preneur.
08/09/2014, 15h24
nchal

Salut,

J'ai téléchargé ton code pour essayer ton P4 et effectivement, si tu joues 3 jetons au milieu, l'IA ne fonctionne pas bien. Mais j'ai remarqué que sans faire cette manipulation, l'IA a un comportement plutôt correct. Bon, c'est pas le champion du monde et si tu prévois des coups sur plusieurs tours, elle voit rien venir mais ça reste cohérent je trouve.
Cependant je n'ai pas pris le temps de parcourir ton code donc je vais peut-être dire de grosses conneries ^^
Si un comportement en particulier te gène, pourquoi ne pas le régler en "dur" ? Tu prend la main sur l'algo de décision et tu lui dis "Si il se passe ça, la seule décision c'est de faire ça". C'est comme ça que je réglerais dans un premier temps ce problème.
08/09/2014, 15h34
Invité

Effectivement, au pire je pourrais faire ça, mais j'aimerais surtout comprendre pourquoi ça ne marche pas. Merci pour le conseil