Projet d'un programme de jeu d'échecs

**Roland Chastain** · 22/01/2013, 11h55

Envoyé par Paul TOTH

je sais pas trop, généralement le boolean c'est && et || et non & tout seul qui est binaire...mais dans le cas présent ça doit revenir au même...comme je le disait plus haut, il faut vérifier l'ordre des opérateurs

Je ne comprends pas trop la distinction que tu fais entre booléen et binaire ; mais j'ai bien noté ton avertissement sur les opérateurs.

L'auteur du programme lui-même a fait une version avec des noms plus longs : il précise qu'il ne garantit pas qu'elle fonctionne !

De toute façon, je vais prendre le temps d'étudier le programme, avec ton code sous la main. Ce sera un bon exercice de chercher les erreurs éventuelles.

Je vais chercher un document de référence sur les opérateurs, en C mais aussi en Pascal. Je sais que la multiplication précède l'addition, mais pour le reste... Comme j'ai toujours des doutes sur le sujet, j'ai pris l'habitude de mettre assez de parenthèses pour ne pas avoir à m'en inquiéter.

**Paul TOTH** · 22/01/2013, 14h03

Envoyé par Roland Chastain

Je ne comprends pas trop la distinction que tu fais entre booléen et binaire ; mais j'ai bien noté ton avertissement sur les opérateurs.

L'auteur du programme lui-même a fait une version avec des noms plus longs : il précise qu'il ne garantit pas qu'elle fonctionne !

De toute façon, je vais prendre le temps d'étudier le programme, avec ton code sous la main. Ce sera un bon exercice de chercher les erreurs éventuelles.

Je vais chercher un document de référence sur les opérateurs, en C mais aussi en Pascal. Je sais que la multiplication précède l'addition, mais pour le reste... Comme j'ai toujours des doutes sur le sujet, j'ai pris l'habitude de mettre assez de parenthèses pour ne pas avoir à m'en inquiéter.

Ben les opérations binaires AND et OR se font sur les bits,
1 OR 2 = 3
alors que les opérations booléennes AND et OR se font sur des booléens.

True OR False = True
Sauf que les booléens n'existent pas en C :

Code :

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

1
2
3
 
  if (c & b) // si (c AND b) <> 0
  if (c && b) // si (c <> 0) AND (b <> 0)

Si une expression C n'est pas booléenne par nature (exemple : a <> b), on ajoute un test "<> 0" pour la traduire en Pascal : "if (a)" donne "if a <> 0 then".

**Roland Chastain** · 25/01/2013, 11h00

J'ai pris la version la plus courte du programme et je me suis lancé dans une adaptation ligne à ligne, en me référant à l'exemple de Paul. Je ne sais pas si j'arriverai au bout, mais j'aurai au moins appris les bases du C.

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
{ Essai d'adaptation en Pascal de la version courte (!) du programme micro-Max,
  à partir d'un exemple de Paul Toth. }
 
program microMax1;
{$APPTYPE CONSOLE}
 
{ http://home.hccnet.nl/h.g.muller/max1.html }
 
//#define F(I,S,N) for(I=S;I<N;I++)
//#define W(A) while(A)
 
//int V=112,M=136,I=8e3,C=799,X,Y,Q,N,
const
  V=112;
  M=136;
  I=8e3;
  C=799;
var
  X,Y,Q,NN: integer;
 
//d[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0,
//     1,1,3,-1,3,5,9,
//     7,-1,11,6,8,3,6},
const
  d: array[0..30] of shortInt =
    (-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0,
     1,1,3,-1,3,5,9,
     7,-1,11,6,8,3,6);
 
//b[128]={6,3,5,7,4,5,3,6};
{ Si la liste ne contient pas assez de valeurs pour toutes les composantes, les
  composantes restantes sont initialisées par zéro. }
var
  b: array[0..127] of shortInt;
 
//char n[]=".?+pkltd?*?PKLTD";
const
  n: string[16] = '.?+pkltd?*?PKLTD';
 
var
  index: integer;
 
begin
  b[0] := 6; b[1] := 3; b[2] := 5; b[3] := 7; b[4] := 4; b[5] := 5; b[6] := 3; b[7] := 6;
  for index := 8 to 127 do b[index] := 0;
 
end.

Pour l'initialisation du tableau b, y a-t-il moyen de faire mieux ?

Concernant le tableau n, est-ce que ça change quelque chose en bien ou en mal de fixer la longueur de la chaîne ?

Enfin, je me demandais si ça ne serait pas une bonne idée d'essayer quelque chose avec l'unité strings qui a une espèce de parenté avec le C, si j'ai bien compris.

**Paul TOTH** · 25/01/2013, 18h09

Oui ça fait partie des choses qu'on ne peut pas faire en Pascal...

Deux solutions :

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
 
const
  b:array[0..127] of Byte=(6,3,5,7,4,5,3,6,0,0,0,0,0....(pour compléter à 127));
 
// autre solution
const 
  b0: array[0..6] of Byte=(6,3,5,7,4,5,3,6);
var 
  b: array[0..127] of Byte;
procedure init_b;
begin
  FillChar(b, SizeOf(b), 0); // des 0 partout
  Move(b0, b, SizeOf(b0)); // copier b0 dans le début de b
end;
 
initialization // lancé automatiquement (dans une unité)
  init_b;

**Roland Chastain** · 28/01/2013, 18h59

Bon, je crois que ce sera un baroud d'honneur pour l'adaptation de micro-Max. J'ai repris tels quels tes exemples et j'ai essayé d'avancer un peu, mais c'est trop difficile. En tout c'était un exercice instructif.

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
 
{ Essai d'adaptation en Pascal de la version courte (!) du programme micro-Max,
  à partir d'un exemple de Paul Toth. }
 
program microMax1;
{$APPTYPE CONSOLE}
 
{ http://home.hccnet.nl/h.g.muller/max1.html }
 
function IIf(const b: boolean; const i, j: integer): integer;
begin
  if b then IIf := i else IIf := j;
end;
 
//#define F(I,S,N) for(I=S;I<N;I++)
//#define W(A) while(A)
 
//int V=112,M=136,I=8e3,C=799,X,Y,Q,N,
const
  V=112;
  M=136;
  I=8e3;
  C=799;
var
  X,Y,Q,NN: integer;
 
//d[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0,
//     1,1,3,-1,3,5,9,
//     7,-1,11,6,8,3,6},
const
  d: array[0..30] of shortInt =
    (-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0,
     1,1,3,-1,3,5,9,
     7,-1,11,6,8,3,6);
 
//b[128]={6,3,5,7,4,5,3,6};
{ Si la liste ne contient pas assez de valeurs pour toutes les composantes, les
  composantes restantes sont initialisées par zéro. }
const 
  b0: array[0..7] of Byte=(6,3,5,7,4,5,3,6);
var 
  b: array[0..127] of Byte;
procedure init_b;
begin
  FillChar(b, SizeOf(b), 0); // des 0 partout
  Move(b0, b, SizeOf(b0)); // copier b0 dans le début de b
end;
{
initialization // lancé automatiquement (dans une unité)
  init_b;
}
//char n[]=".?+pkltd?*?PKLTD";
const
  n = '.?+pkltd?*?PKLTD';
 
//D(k,q,l,e,x,n)
//int k,q,l,e,x,n;
function DD(k,q,l,e,x,n: integer): integer;
//{
// int i=0,j,t,p,u,r,y, m = n>1|q>e ? q : e, v,h,z;
var i,j,t,p,u,r,y,m,v,h,z: integer;
begin
  i := 0;
  m := IIf((n>1) or (q>e), q, e);
//N++;
  Inc(NN);
//do{
  repeat
 
//}W(i=i+9&~M);
    Inc(i, (i+9) and (not M)); // ?
  until (i = 0);
end;
 
begin
  X := 0; Y := 0; Q := 0; NN := 0;
  init_b;
end.

**Dr.Who** · 29/01/2013, 19h18

@Roland

ton problème viens de la :

Code :

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

1
2
3
4
5
6
 
procedure iToXY(const i: integer; var x: integer; var y: integer);
begin
  x := i div 10;
  y := i mod 10;
end;

une Division ... puis ... un modulo.

Hors ... Div conserve le modulo et Mod passe d'abord par un Div, en assembleur.

Tu as l'air d'utiliser Delphi donc correction un peu plus performante :

Code :

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

1
2
3
4
5
6
7
8
9
 
uses Math;
 
const NG = RTLVersion >= 18.0;
 
procedure iToXY(const i: integer; var x: word; var y: word);{$IF NG}inline;{$IFEND}
begin
  divMod(i, 10, X, Y);
end;

Note le "inline" qui générera le même code, que si tu appel DivMod directement, si tu possède Delphi >= 2007 ! :

Code asm :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
; Project3.dpr.18: iToXY(80, X, Y);
push $00412d8e
mov ecx,$00412d8c
mov dx,$000a
mov eax,$00000050
call DivMod
 
; Project3.dpr.20: divMod(80, 10, X, Y);
push $00412d8e
mov ecx,$00412d8c
mov dx,$000a
mov eax,$00000050
call DivMod

**Roland Chastain** · 29/01/2013, 23h49

Merci Dr.Who pour ton exemple, dans lequel il y a plusieurs choses que je ne connaissais pas.

Au passage, l'assembleur aussi ça m'intéresse. Il faudrait que j'en mette un bout dans mon programme, histoire de frimer un peu.

**Roland Chastain** · 04/03/2013, 12h16

Je reviens un peu en arrière dans la discussion. J'avais parlé du programme d'échecs Rebel (renommé ProDeo et désormais gratuit) et de son livre d'ouvertures.

Voici un exemple qui montre comment utiliser la bibliothèque dynamique rebelbook.dll. Je n'ai fait que retoucher l'exemple Delphi inclus dans l'archive, pour le rendre indépendant. (Il y a deux archives différentes, l'une contenant les livres et le code C, l'autre la DLL.)

Dans cet exemple, on consulte le livre sur le premier coup de la partie.

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
 
{ Exemple d'utilisation de rebelbook.dll
  D'après uRebelBook.pas par Andres Valverde
  http://www.top-5000.nl/tools.htm
  Compilation Delphi 6 }
 
program testbook;
{$APPTYPE CONSOLE}
{$I+}
 
uses
  Windows, SysUtils;
 
const
  EPD1 = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq -';
{ Représentation de la position initiale au format EPD. }
 
var
  RebelDLLHandle: tHandle;
  RebelBookLoaded: boolean = false;
  TourBookFileName: string = '..\PRODEOBOOK\TOURBOOK.BIN';
  MainBookFileName: string = '..\PRODEOBOOK\MAINBOOK.BIN';
 
type 
  TFIND_OPENING = function(EPD, vFROM, vTO, vFROM1, vFROM2, vTO1, vTO2: pChar; var numMoves: integer): integer; cdecl;
  TINIT_REBEL_BOOK = function(TourBookFileName, MainBookFileName: pChar): integer; cdecl;
  TCLOSE_REBEL_BOOK = procedure; cdecl;
 
const
  FIND_OPENING: TFIND_OPENING = nil;
  INIT_REBEL_BOOK: TINIT_REBEL_BOOK = nil;
  CLOSE_REBEL_BOOK: TCLOSE_REBEL_BOOK = nil;
 
procedure InitRebelBook;
const
  msg1 = 'DLL loaded!';
  msg2 = 'DLL not loaded!';
  msg3 = 'Book loaded!';
  msg4 = 'Error loading book: tourbook.bin not found!';
  msg5 = 'Error loading book: mainbook.bin not found!';
  msg6 = 'Error loading book: error ';
  msg7 = 'Unexpected problem!';
var
  error: integer;
  buffer, buffer1: array[0..255] of char;
  p, q: pChar;
begin
  RebelDLLHandle := LoadLibrary('rebelbook.dll');
  if RebelDLLHandle <> 0 then
  begin
    RebelBookLoaded := true;
    @FIND_OPENING := GetProcAddress(RebelDLLHandle, 'FIND_OPENING');
    @INIT_REBEL_BOOK := GetProcAddress(RebelDLLHandle, 'INITIALIZE');
    @CLOSE_REBEL_BOOK := GetProcAddress(RebelDLLHandle, 'CLOSE_BOOK');
    WriteLn(msg1);
  end else
  begin
    RebelBookLoaded := false;
    WriteLn(msg2);
    Exit;
  end;
  p := StrPCopy(buffer, TourBookFileName);
  q := StrPCopy(buffer1, MainBookFileName);
  try
    error := INIT_REBEL_BOOK(p, q);
    case ERROR of
      0:begin
          WriteLn(msg3);
          RebelBookLoaded:=true;
        end;
      1:begin
          WriteLn(msg4);
          RebelBookLoaded:=true
        end;
      3:begin
          RebelBookLoaded:=false;
          WriteLn(msg5);
        end;
      else
        begin
          RebelBookLoaded:=false;
          WriteLn(msg6+IntToStr(ERROR));
        end;
    end;
  except
    WriteLn(msg7);
  end;
end;
 
function RebelBookMove: string;
var
  EPD: array[0..199] of char;
  vFROM, vTO: array [0..9] of char;
  vFROM1, vFROM2, vTO1, vTO2: array [0..19] of char;
  n: integer;
begin
  result:='';
  StrPCopy(EPD, EPD1);
  if FIND_OPENING(@EPD, @vFROM, @vTO, @vFROM1, @vFROM2, @vTO1, @vTO2, n) = 0 then
  begin
    if n=0 then
      Exit;
    result := LowerCase(vFROM+vTO);
  end;
end;
 
begin
  InitRebelBook;
  if RebelBookLoaded then
  begin
    WriteLn('Book move=', RebelBookMove);
    CLOSE_REBEL_BOOK;
    FreeLibrary(RebelDLLHandle);
  end;
  ReadLn;
end.

DLL loaded!
Book loaded!
Book move=e2e4

Par contre je n'ai réussi à compiler ni avec Virtual Pascal ni avec FreePascal. Je vais chercher les corrections à faire mais si vous les trouvez avant moi, vous êtes les bienvenus.

**Roland Chastain** · 06/03/2013, 22h01

Pour compiler l'exemple ci-dessus avec FreePascal, il suffit d'ajouter la directive {$MODE DELPHI}.

Voilà de quoi ajouter de la valeur à un programme d'échecs !

En même temps je ne sais pas comment ce code fonctionne. Dans un sens, ce serait plus intéressant de repartir du C.

Ou même de continuer à utiliser le livre que j'ai fait moi-même avec "patience et longueur de temps" :

Code :

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

e2e4e7e5g1f3b8c6f1b5a7a6b5a4g8f6e1g1b7b5a4b3c8b7f1e1f8c5c2c3d7d6d2d4c5b6c1g5h7h6g5h4e8g8d1d3g7g5

**Alcatîz** · 10/03/2013, 09h44

Virtual Pascal ne supporte en effet pas la directive cdecl dans une déclaration de fonction dans la section types.
Je pense que tu peux contourner le problème en encadrant les appels avec les directives {&CDecl+} et {&CDecl-} :

Code :

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

1
2
3
{&CDecl+}
error := INIT_REBEL_BOOK(p, q);
{&CDecl-}

A tester.

**Roland Chastain** · 12/03/2013, 19h06

Merci Alcatîz, pour cette indication. Après réflexion, ça ne m'intéresse pas tellement d'utiliser la DLL. J'ai regardé le module en C qui accompagne le livre : ça ne m'a pas paru trop compliqué. Donc je crois que je vais plutôt prendre le temps de comprendre comment le livre est fait et d'écrire mon propre code.

En attendant, pour le projet sur lequel je travaille, je pense utiliser mon propre livre, sous la forme d'une table de chaîne dans un fichier .rc :

Code :

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

1
2
3
4
5
6
7
STRINGTABLE 
{
 1, "abcd"
 2, "efgh"
 3, "ijkl"
 4, "mnop"
}

**Roland Chastain** · 17/11/2013, 18h16

Le temps passe vite !

Voici un moteur de jeu d'échecs que je viens de finir. C'est une nouvelle version d'un code que j'ai déjà proposé. Maintenant je vais refaire l'interface.

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
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
 
unit Moteur;
 
{
  Moteur pour un jeu d'échecs.
  Adaptation d'un programme de Jürgen Schlottke.
  https://sites.google.com/site/maciejszmit/my-projects/computer-chess
  http://maciej.szmit.info/resources/JSSchach.zip
}
 
{$IFDEF VPASCAL}{&USE32+}{$ELSE}{$IFDEF FPC}{$MODE DELPHI}{$ENDIF}{$ENDIF}
 
interface
 
type
  tDamier = array[-10..109] of integer; // 11 - 21 .. 88 + 21
 
  tRoque = (e1g1, e1c1, e8g8, e8c8);
 
  tCoup = record
    a, b, v: integer; // départ, arrivée, valeur
  end;
 
  tListe = array[1..100] of tCoup;
 
  tPosition = record
    damier: tDamier;
    couleur: integer; // couleur active
    roque: array[tRoque] of boolean;
    enPassant: array[-1..1] of integer; // possibilité de prise en passant (case d'arrivée ou 0) en fonction de la couleur du pion à prendre
    coups: tListe;
    nombre: integer; // nombre de coups
    balance: integer;
  end;
 
procedure Installe;
function ChainePositionCourante: string;
function CoupUtilisateur(s: string): boolean; // vérifie la légalité du coup et le joue
procedure ChangeProfondeur(const aProfondeur, aProfondeurMaximale: integer);
function CoupMoteur(var drapeau: integer): string; // renvoie le coup et le joue
 
implementation
 
const
  cNeant    = 000;
  cPion     = 002;
  cFou      = 006;
  cCavalier = 007;
  cTour     = 010;
  cDame     = 019;
  cRoi      = 126;
  cDehors   = 127;
 
  mPion    : array[1..4] of integer = (+00 +01, +00 +02, -10 +01, +10 +01);
  mCavalier: array[1..8] of integer = (+10 +02, +20 +01, +20 -01, +10 -02,
                                       -10 -02, -20 -01, -20 +01, -10 +02);
  mFou     : array[1..4] of integer = (+10 +01, -10 -01, +10 -01, -10 +01);
  mTour    : array[1..4] of integer = (+00 -01, +00 +01, -10 +00, +10 +00);
  mRoi     : array[1..8] of integer = (+00 -01, +00 +01, -10 +00, +10 +00,
                                       +10 +01, -10 -01, +10 -01, -10 +01);
 
var
  positionCourante, positionInitiale: tPosition;
  demiCoups, profondeur, profondeurMaximale, seuil: integer;
  meilleurs: tListe;
 
function EvaluationMaterielle(const aPosition: tPosition; const aCouleur: integer): integer;
begin
  result := aPosition.balance * aCouleur;
end;
 
procedure Installe;
const
  cDamier: tDamier = (
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 010, 002, 000, 000, 000, 000,-002,-010, 127,
    127, 007, 002, 000, 000, 000, 000,-002,-007, 127,
    127, 006, 002, 000, 000, 000, 000,-002,-006, 127,
    127, 019, 002, 000, 000, 000, 000,-002,-019, 127,
    127, 126, 002, 000, 000, 000, 000,-002,-126, 127,
    127, 006, 002, 000, 000, 000, 000,-002,-006, 127,
    127, 007, 002, 000, 000, 000, 000,-002,-007, 127,
    127, 010, 002, 000, 000, 000, 000,-002,-010, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127
  );
var
  r: tRoque;
begin
  with positionInitiale do
  begin
    damier := cDamier;
    couleur := +1;
    for r := e1g1 to e8c8 do
      roque[r] := true;
    enPassant[-1] := 0;
    enPassant[+1] := 0;
    balance := 0;
  end;
  positionCourante := positionInitiale;
  demiCoups := 0;
  profondeur := 3;
  profondeurMaximale := 5;
end;
 
function ChainePositionCourante: string;
var
  x, y: integer;
  c: char;
begin
  result :=
  '  1 2 3 4 5 6 7 8'#13#10 +
  '8                '#13#10 +
  '7                '#13#10 +
  '6                '#13#10 +
  '5                '#13#10 +
  '4                '#13#10 +
  '3                '#13#10 +
  '2                '#13#10 +
  '1                '#13#10 +
  '  1 2 3 4 5 6 7 8';
  for x := 1 to 8 do
    for y := 1 to 8 do
    begin
      case Abs(positionCourante.damier[10 * x + y]) of
        cNeant   : c := '.';
        cPion    : c := 'P';
        cCavalier: c := 'C';
        cFou     : c := 'F';
        cTour    : c := 'T';
        cRoi     : c := 'R';
        cDame    : c := 'D';
      end;
      if positionCourante.damier[10 * x + y] < cNeant then
        Inc(c, Ord('a') - Ord('A'));
      result[2 * x + 19 * (9 - y) + 1] := c;
    end;
end;
 
procedure Deplace(var aPosition: tPosition; aDepart, aArrivee: integer; const aPromotion: integer);
begin
  with aPosition do
  begin
    if damier[aDepart] * couleur = cRoi then
      case aDepart of
        51: begin
              roque[e1g1] := false;
              roque[e1c1] := false;
            end;
        58: begin
              roque[e8g8] := false;
              roque[e8c8] := false;
            end;
      end;
    if damier[aDepart] * couleur = cTour then
      case aDepart of
        81: roque[e1g1] := false;
        11: roque[e1c1] := false;
        88: roque[e8g8] := false;
        18: roque[e8c8] := false;
      end;
    if ((aArrivee - aDepart) * (aArrivee - aDepart) = 4) and (damier[aDepart] * couleur = cPion) then
      enPassant[couleur] := aDepart + mPion[1] * couleur
    else
      enPassant[couleur] := 0;
    if (aArrivee = enPassant[-1 * couleur]) and (damier[aDepart] * couleur = cPion) then
    begin
      enPassant[couleur] := 0;
      Deplace(aPosition, aDepart, (aArrivee div 10) * 10 + aDepart mod 10, cDame);
      couleur := -1 * couleur;
      aDepart := (aArrivee div 10) * 10 + aDepart mod 10;
    end;
    if (aDepart in [51, 58]) and (aArrivee in [71, 31, 78, 38]) and (damier[aDepart] * couleur = cRoi) then
    begin
      damier[aArrivee] := damier[aDepart];
      damier[aDepart] := cNeant;
      if aArrivee div 10 = 7 then
      begin
        aDepart := (aDepart mod 10) + 80;
        aArrivee := aDepart - 20;
      end else
      begin
        aDepart := (aDepart mod 10) + 10;
        aArrivee := aDepart + 30;
      end;
      damier[aArrivee] := damier[aDepart];
      damier[aDepart] := cNeant;
    end else
    begin
      balance := balance - damier[aArrivee];
      damier[aArrivee] := damier[aDepart];
      damier[aDepart] := cNeant;
      if ((aArrivee mod 10 = 1) or (aArrivee mod 10 = 8)) and (damier[aArrivee] * couleur = cPion) then
      begin
        damier[aArrivee] := aPromotion * couleur;
        balance := balance + (aPromotion - cPion) * couleur;
      end;
    end;
    couleur := -1 * couleur;
  end;
end;
 
procedure Ajouter(var aPosition: tPosition; const aDepart, aArrivee: integer);
begin
  with aPosition do
  begin
    Inc(nombre);
    coups[nombre].a := aDepart;
    coups[nombre].b := aArrivee;
  end;
end;
 
procedure GenereCoupsOrdinaires(var aPosition: tPosition);
var
  depart, arrivee: integer;
  x, y: integer;
  i, j: integer;
begin
  with aPosition do
  begin
    nombre := 0;
    for x := 1 to 8 do
      for y := 1 to 8 do
      begin
        depart := 10 * x + y;
        if damier[depart] <> cNeant then
        begin
          case damier[depart] * couleur of
            cPion:
              begin
                arrivee := depart + mPion[1] * couleur;
                if damier[arrivee] = cNeant then
                begin
                  Ajouter(aPosition, depart, arrivee);
                  if (couleur = +1) and (y = 2) or (couleur = -1) and (y = 7) then
                  begin
                    arrivee := depart + mPion[2] * couleur;
                    if (damier[arrivee] = cNeant) then
                      Ajouter(aPosition, depart, arrivee);
                  end;
                end;
                for i := 3 to 4 do
                begin
                  arrivee := depart + mPion[i] * couleur;
                  if (-1 * damier[arrivee] * couleur in [cPion..cRoi]) or (arrivee = enPassant[-1 * couleur]) then
                    Ajouter(aPosition, depart, arrivee);
                end;
              end;
            cCavalier:
              begin
                for i := 1 to 8 do
                begin
                  arrivee := depart + mCavalier[i];
                  if -1 * damier[arrivee] * couleur in [cNeant..cRoi] then
                    Ajouter(aPosition, depart, arrivee);
                end;
              end;
            cFou:
              begin
                for i := 1 to 4 do
                begin
                  arrivee := depart;
                  repeat
                    Inc(arrivee, mFou[i]);
                    if -1 * damier[arrivee] * couleur in [cNeant..cRoi] then
                      Ajouter(aPosition, depart, arrivee);
                  until damier[arrivee] <> cNeant;
                end;
              end;
            cTour:
              begin
                for i := 1 to 4 do
                begin
                  arrivee := depart;
                  repeat
                    Inc(arrivee, mTour[i]);
                    if -1 * damier[arrivee] * couleur in [cNeant..cRoi] then
                      Ajouter(aPosition, depart, arrivee);
                  until damier[arrivee] <> 0;
                end;
              end;
            cRoi:
              begin
                for i := 1 to 8 do
                begin
                  arrivee := depart + mRoi[i];
                  if -1 * damier[arrivee] * couleur in [cNeant..cRoi] then
                  begin
                    j := 0;
                    repeat
                      Inc(j);
                    until (-1 * damier[arrivee + mRoi[j]] * couleur = cRoi) or (j = 8);
                    if j = 8 then
                      Ajouter(aPosition, depart, arrivee);
                  end;
                end;
              end;
            cDame:
              begin
                for i := 1 to 8 do
                begin
                  arrivee := depart;
                  repeat
                    Inc(arrivee, mRoi[i]);
                    if -1 * damier[arrivee] * couleur in [cNeant..cRoi] then
                      Ajouter(aPosition, depart, arrivee);
                  until damier[arrivee] <> cNeant;
                end;
              end;
          end;
        end;
      end;
  end;
end;
 
function Echec(var aPosition: tPosition): boolean;
var
  i: integer;
begin
  result := false;
  with aPosition do
  begin
    couleur := -1 * couleur;
    GenereCoupsOrdinaires(aPosition);
    couleur := -1 * couleur;
    result := false;
    for i := 1 to nombre do
      if damier[coups[i].b] * couleur = cRoi then
        result := true;
  end;
end;
 
function EchecRoque(var aPosition: tPosition; const departRoi, pasRoi: integer): boolean;
var
  i: integer;
begin
  result := false;
  with aPosition do
  begin
    couleur := -1 * couleur;
    GenereCoupsOrdinaires(aPosition);
    couleur := -1 * couleur;
    result := false;
    for i := 1 to nombre do
      if (coups[i].b mod 10 = departRoi mod 10) and ((coups[i].b - departRoi) div pasRoi >= 0) then
        result := true;
  end;
end;
 
procedure GenereRoque(var aPosition: tPosition; const departRoi, pasRoi, departTour: integer);
var
  copiePosition: tPosition;
  i: integer;
begin
  with aPosition do
  begin
    if damier[departTour] * couleur <> cTour then
      exit;
    i := departRoi + pasRoi;
    repeat
      if damier[i] <> cNeant then
        exit;
      Inc(i, pasRoi);
    until i = departTour;
    copiePosition := aPosition;
    if not EchecRoque(copiePosition, departRoi, pasRoi) then
      Ajouter(aPosition, departRoi, departRoi + 2 * pasRoi);
  end;
end;
 
procedure GenereCoups(var aPosition: tPosition);
begin
  GenereCoupsOrdinaires(aPosition);
  with aPosition do
  begin
    if couleur = +1 then
    begin
      if roque[e1g1] then
        GenereRoque(aPosition, 51, +10, 81);
      if roque[e1c1] then
        GenereRoque(aPosition, 51, -10, 11);
    end else
    begin
      if roque[e8g8] then
        GenereRoque(aPosition, 58, +10, 88);
      if roque[e8c8] then
        GenereRoque(aPosition, 58, -10, 18);
    end;
  end;
end;
 
function EvaluationRecursive(var aPosition: tPosition; aCouleur, aProfondeur, alpha: integer): integer;
var
  v, index: integer;
  copiePosition: tPosition;
  beta: integer;
  arret: boolean;
begin
  GenereCoups(aPosition);
  index := 0;
  beta := -32000 * aPosition.couleur * aCouleur;
  arret := false;
  while (index < aPosition.nombre) and not arret do
  begin
    Inc(index);
    copiePosition := aPosition;
    with aPosition do Deplace(copiePosition, coups[index].a, coups[index].b, cDame);
    if ((aProfondeur >= profondeur) and (aPosition.damier[aPosition.coups[index].b] = 0)) or (aProfondeur = profondeurMaximale) then
      v := EvaluationMaterielle(copiePosition, aCouleur)
    else
      v := EvaluationRecursive(copiePosition, aCouleur, aProfondeur + 1, beta);
    if aPosition.couleur = aCouleur then
    begin
      if v > beta then
        beta := v;
      if beta > alpha then
        arret := true;
    end else
    begin
      if v < beta then
        beta := v;
      if beta < alpha then
        arret := true;
    end;
    aPosition.coups[index].v := v;
  end;
  result := beta;
end;
 
function CoupUtilisateur(s: string): boolean;
var
  i: integer;
  copiePosition: tPosition;
  coup, erreur: integer;
  depart, arrivee: integer;
  existe: boolean;
begin
  result := true;
  s[1] := Chr(Ord(s[1]) - 48);
  s[3] := Chr(Ord(s[3]) - 48);
  Val(s, coup, erreur);
  if erreur = 0 then
  begin
    depart := coup div 100;
    arrivee := coup mod 100;
    GenereCoups(positionCourante);
    existe := false;
    with positionCourante do
      for i := 1 to nombre do
        if coup = 100 * coups[i].a + coups[i].b then
          existe := true;
    if existe then
    begin
      copiePosition := positionCourante;
      Deplace(copiePosition, depart, arrivee, cDame);
      copiePosition.couleur := -1 * copiePosition.couleur;
      if Echec(copiePosition) then
        result := false
      else
      begin
        Deplace(positionCourante, depart, arrivee, cDame);
        Inc(demiCoups);
      end;
    end
    else
      result := false;
  end
  else
    result := false;
end;
 
function ChaineCoup(const aDepart, aArrivee: integer): string;
begin
  Str(100 * aDepart + aArrivee, result);
  result[1] := Chr(Ord(result[1]) + Ord('0'));
  result[3] := Chr(Ord(result[3]) + ord('0'));
end;
 
function IdentiquePositionInitiale(const aPosition: tPosition; const i: integer): boolean;
begin
  result := aPosition.damier[i] = positionInitiale.damier[i];
end;
 
function MeilleurCoup: integer;
var
  copiePosition: tPosition;
  i, j: integer;
  maximum: integer;
  n: integer; // nombre de "meilleurs", c'est-à-dire de coups admis dans la deuxième liste
begin
  with positionCourante do
  begin
    n := 0;
    for i := 1 to nombre do
    begin
      if coups[i].v = seuil then
      begin
        Inc(n);
        meilleurs[n].a := coups[i].a;
        meilleurs[n].b := coups[i].b;
        meilleurs[n].v := 0;
      end;
    end;
  end;
  maximum := 0;
  result := 1;
  for i := 1 to n do
  begin
    copiePosition := positionCourante;
    meilleurs[i].v := 0;
    with copiePosition do
    begin
      if IdentiquePositionInitiale(copiePosition, meilleurs[i].a) then
      begin
        Inc(meilleurs[i].v, 5);
        if damier[meilleurs[i].a] * couleur = cPion then
          Inc(meilleurs[i].v, 2);
      end;
      if damier[meilleurs[i].a] * couleur = cRoi then
        Dec(meilleurs[i].v, 10);
      if (demiCoups < 32) and (damier[meilleurs[i].a] * couleur in [cPion, cFou, cCavalier]) then
        Inc(meilleurs[i].v, 20);
      if (meilleurs[i].a div 10 = 1)
      or (meilleurs[i].a div 10 = 8)
      or (meilleurs[i].a mod 10 = 1)
      or (meilleurs[i].a mod 10 = 8) then
        Inc(meilleurs[i].v, 2);
      if (meilleurs[i].b div 10 = 1)
      or (meilleurs[i].b div 10 = 8)
      or (meilleurs[i].b mod 10 = 1)
      or (meilleurs[i].b mod 10 = 8) then
        Dec(meilleurs[i].v, 2);
    end;
    copiePosition := positionCourante;
    Deplace(copiePosition, meilleurs[i].a, meilleurs[i].b, cDame);
    if IdentiquePositionInitiale(copiePosition, meilleurs[i].b) then
      Dec(meilleurs[i].v, 10);
    copiePosition.couleur := -1 * copiePosition.couleur;
    GenereCoupsOrdinaires(copiePosition);
    with copiePosition do
    begin
      for j := 1 to nombre do
      begin
        Inc(meilleurs[i].v);
        if damier[coups[j].b] <> cNeant then
          Inc(meilleurs[i].v);
      end;
    end;
    copiePosition.couleur := -1 * copiePosition.couleur;
    GenereCoupsOrdinaires(copiePosition);
    with copiePosition do
    begin
      for j := 1 to nombre do
      begin
        Dec(meilleurs[i].v);
        if damier[coups[j].b] <> cNeant then
          Dec(meilleurs[i].v);
      end;
    end;
    if meilleurs[i].v >= maximum then
    begin
      maximum := meilleurs[i].v;
      result := i;
    end;
  end;
end;
 
procedure ChangeProfondeur(const aProfondeur, aProfondeurMaximale: integer);
begin
  profondeur := aProfondeur;
  profondeurMaximale := aProfondeurMaximale;
end;
 
function CoupMoteur(var drapeau: integer): string;
var
  i: integer;
  echecAnterieur: boolean;
begin
  seuil := EvaluationRecursive(positionCourante, positionCourante.couleur, 1, 32000);
  i := MeilleurCoup;
  Inc(demiCoups);
  echecAnterieur := Echec(positionCourante);
  Deplace(positionCourante, meilleurs[i].a, meilleurs[i].b, cDame);
  result := ChaineCoup(meilleurs[i].a, meilleurs[i].b);
  positionCourante.couleur := -1 * positionCourante.couleur;
  if Echec(positionCourante) then
  begin
    if echecAnterieur then
      drapeau := 3
    else
      drapeau := 2;
  end else
  begin
    positionCourante.couleur := -1 * positionCourante.couleur;
    if Echec(positionCourante) then
      drapeau := 1
    else
      drapeau := 0;
  end;
end;
 
end.

Je n'ai testé la compilation qu'avec Virtual Pascal, mais je pense que ça devrait aller aussi avec Free Pascal ou Delphi.

Si cela vous intéresse, voici une version en Basic du même programme. Merci à Paul TOTH pour la technique permettant d'obtenir une icône à partir d'un fichier au format SVG, et merci à Alcatîz pour l'exemple d'utilisation de rebelbook.dll.

**Roland Chastain** · 26/11/2013, 13h41

J'ai transformé mon record en object. J'avais des doutes sur le succès de l'opération, notamment à cause des variables locales de type tPosition (le type de l'objet lui-même).

Je me suis laissé guider par les erreurs de compilation. Surprise, ça a l'air de marcher : le premier essai donne le même résultat qu'avec la version précédente.

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
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
 
program Automate2;
 
{$IFDEF VPASCAL}
  {&PMTYPE VIO}
  {&USE32+}
  {$H+}
{$ELSE}
  {$APPTYPE CONSOLE}
  {$IFDEF FPC}{$MODE DELPHI}{$H+}{$ENDIF}
{$ENDIF}
 
uses
  SysUtils;
 
type
  tDamier = array[11 - 21..88 + 21]of integer;
  tCoup = record
    a, b, note: integer;
  end;
  tListe = array[1..100]of tCoup;
  tRoque = (
    e1g1,
    e1c1,
    e8g8,
    e8c8
  );
  tPosition = object
    damier : tDamier;
    trait  : integer;
    roque  : array[tRoque]of boolean;
    passant: array[-1..+1]of integer;
    coups  : tListe;
    nombre : integer;
    balance: integer;
    function Evaluation(const aCouleur: integer): integer;
    procedure Deplace(a, b: integer; const aPromotion: integer);
    procedure Ajouter(const a, b: integer);
    procedure GenereOrdinaires;
    function Echec: boolean;
    function EchecRoque(const aRoi, aPas: integer): boolean;
    procedure GenereRoque(const aRoi, aPas, aTour: integer);
    procedure GenereCoups;
    function EvaluationR(const aCouleur, aProfondeur, a: integer): integer;
    function IdentiqueInitiale(const n: integer): boolean;
  end;
 
const
  cNeant    = 000;
  cPion     = 002;
  cFou      = 006;
  cCavalier = 007;
  cTour     = 010;
  cDame     = 019;
  cRoi      = 126;
  cDehors   = 127;
  mPion    : array[1..4]of integer = (+01, +02, -09, +11);
  mFou     : array[1..4]of integer = (+11, -11, +09, -09);
  mTour    : array[1..4]of integer = (-01, +01, -10, +10);
  mCavalier: array[1..8]of integer = (+12, +21, +19, +08, -12, -21, -19, -08);
  mRoi     : array[1..8]of integer = (-01, +01, -10, +10, +11, -11, +09, -09);
 
var
  courante, initiale: tPosition;
  demi: integer;
  profondeur, maximale: integer;
  selection: tListe;
 
function tPosition.Evaluation(const aCouleur: integer): integer;
begin
  result := self.balance * aCouleur;
end;
 
procedure tPosition.Deplace(a, b: integer; const aPromotion: integer);
begin
  with self do
  begin
    if damier[a] * trait = cRoi then
      case a of
        51:
          begin
            roque[e1g1] := false;
            roque[e1c1] := false;
          end;
        58:
          begin
            roque[e8g8] := false;
            roque[e8c8] := false;
          end;
      end;
    if damier[a] * trait = cTour then
      case a of
        81: roque[e1g1] := false;
        11: roque[e1c1] := false;
        88: roque[e8g8] := false;
        18: roque[e8c8] := false;
      end;
    if ((b - a) * (b - a) = 4) and (damier[a] * trait = cPion) then
      passant[trait] := a + mPion[1] * trait
    else
      passant[trait] := 0;
    if (b = passant[-1 * trait]) and (damier[a] * trait = cPion) then
    begin
      passant[trait] := 0;
      Deplace(a, (b div 10) * 10 + a mod 10, cDame);
      trait := -1 * trait;
      a := (b div 10) * 10 + a mod 10;
    end;
    if (a in [51, 58]) and (b in [71, 31, 78, 38])
    and (damier[a] * trait = cRoi) then
    begin
      damier[b] := damier[a];
      damier[a] := cNeant;
      if b div 10 = 7 then
      begin
        a := (a mod 10) + 80;
        b := a - 20;
      end else
      begin
        a := (a mod 10) + 10;
        b := a + 30;
      end;
      damier[b] := damier[a];
      damier[a] := cNeant;
    end else
    begin
      balance := balance - damier[b];
      damier[b] := damier[a];
      damier[a] := cNeant;
      if ((b mod 10 = 1) or (b mod 10 = 8))
      and (damier[b] * trait = cPion) then
      begin
        damier[b] := aPromotion * trait;
        balance := balance + (aPromotion - cPion) * trait;
      end;
    end;
    trait := -1 * trait;
  end;
end;
 
procedure tPosition.Ajouter(const a, b: integer);
begin
  with self do
  begin
    Inc(nombre);
    coups[nombre].a := a;
    coups[nombre].b := b;
  end;
end;
 
procedure tPosition.GenereOrdinaires;
var
  a, b, x, y, i, j: integer;
begin
  with self do
  begin
    nombre := 0;
    for x := 1 to 8 do
      for y := 1 to 8 do
      begin
        a := 10 * x + y;
        if damier[a] <> cNeant then
        begin
          case damier[a] * trait of
            cPion:
              begin
                b := a + mPion[1] * trait;
                if damier[b] = cNeant then
                begin
                  Ajouter(a, b);
                  if (trait = 1) and (y = 2) or (trait = -1) and (y = 7) then
                  begin
                    b := a + mPion[2] * trait;
                    if (damier[b] = cNeant) then
                      Ajouter(a, b);
                  end;
                end;
                for i := 3 to 4 do
                begin
                  b := a + mPion[i] * trait;
                  if (-1 * damier[b] * trait in [cPion..cRoi])
                  or (b = passant[-1 * trait]) then
                    Ajouter(a, b);
                end;
              end;
            cCavalier:
              for i := 1 to 8 do
              begin
                b := a + mCavalier[i];
                if -1 * damier[b] * trait in [cNeant..cRoi] then
                  Ajouter(a, b);
              end;
            cFou:
              for i := 1 to 4 do
              begin
                b := a;
                repeat
                  Inc(b, mFou[i]);
                  if -1 * damier[b] * trait in [cNeant..cRoi] then
                    Ajouter(a, b);
                until damier[b] <> cNeant;
              end;
            cTour:
              for i := 1 to 4 do
              begin
                b := a;
                repeat
                  Inc(b, mTour[i]);
                  if -1 * damier[b] * trait in [cNeant..cRoi] then
                    Ajouter(a, b);
                until damier[b] <> 0;
              end;
            cRoi:
              for i := 1 to 8 do
              begin
                b := a + mRoi[i];
                if -1 * damier[b] * trait in [cNeant..cRoi] then
                begin
                  j := 0;
                  repeat
                    Inc(j);
                  until (-1 * damier[b + mRoi[j]] * trait = cRoi) or (j = 8);
                  if j = 8 then
                    Ajouter(a, b);
                end;
              end;
            cDame:
              for i := 1 to 8 do
              begin
                b := a;
                repeat
                  Inc(b, mRoi[i]);
                  if -1 * damier[b] * trait in [cNeant..cRoi] then
                    Ajouter(a, b);
                until damier[b] <> cNeant;
              end;
          end;
        end;
      end;
  end;
end;
 
function tPosition.Echec: boolean;
var
  i: integer;
begin
  result := false;
  with self do
  begin
    trait := -1 * trait;
    GenereOrdinaires;
    trait := -1 * trait;
    result := false;
    for i := 1 to nombre do
      if damier[coups[i].b] * trait = cRoi then
      begin
        result := true;
        exit;
      end;
  end;
end;
 
function tPosition.EchecRoque(const aRoi, aPas: integer): boolean;
var
  i: integer;
begin
  result := false;
  with self do
  begin
    trait := -1 * trait;
    GenereOrdinaires;
    trait := -1 * trait;
    result := false;
    for i := 1 to nombre do
      if (coups[i].b mod 10 = aRoi mod 10)
      and ((coups[i].b - aRoi) div aPas >= 0) then
      begin
        result := true;
        exit;
      end;
  end;
end;
 
procedure tPosition.GenereRoque(const aRoi, aPas, aTour: integer);
var
  copie: tPosition;
  a: integer;
begin
  with self do
  begin
    if damier[aTour] * trait <> cTour then
      exit;
    a := aRoi + aPas;
    repeat
      if damier[a] <> cNeant then
        exit;
      Inc(a, aPas);
    until a = aTour;
    copie := self;
    if not copie.EchecRoque(aRoi, aPas) then
      Ajouter(aRoi, aRoi + 2 * aPas);
  end;
end;
 
procedure tPosition.GenereCoups;
begin
  GenereOrdinaires;
  with self do
  begin
    if trait = 1 then
    begin
      if roque[e1g1] then
        GenereRoque(51, +10, 81);
      if roque[e1c1] then
        GenereRoque(51, -10, 11);
    end else
    begin
      if roque[e8g8] then
        GenereRoque(58, +10, 88);
      if roque[e8c8] then
        GenereRoque(58, -10, 18);
    end;
  end;
end;
 
function tPosition.EvaluationR(const aCouleur, aProfondeur, a: integer): integer;
var
  v, i, b: integer;
  copie: tPosition;
  arret: boolean;
begin
  GenereCoups;
  i := 0;
  b := -32000 * self.trait * aCouleur;
  arret := false;
  while (i < self.nombre) and not arret do
  begin
    Inc(i);
    copie := self;
    copie.Deplace(copie.coups[i].a, copie.coups[i].b, cDame);
    if (aProfondeur >= profondeur) and (self.damier[self.coups[i].b] = cNeant)
    or (aProfondeur = maximale) then
      v := copie.Evaluation(aCouleur)
    else
      v := copie.EvaluationR(aCouleur, aProfondeur + 1, b);
    if self.trait = aCouleur then
    begin
      if v > b then
        b := v;
      if b > a then
        arret := true;
    end else
    begin
      if v < b then
        b := v;
      if b < a then
        arret := true;
    end;
    self.coups[i].note := v;
  end;
  result := b;
end;
 
function tPosition.IdentiqueInitiale(const n: integer): boolean;
begin
  result := self.damier[n] = initiale.damier[n];
end;
 
procedure Installe;
const
  cDamier: tDamier = (
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 010, 002, 000, 000, 000, 000,-002,-010, 127,
    127, 007, 002, 000, 000, 000, 000,-002,-007, 127,
    127, 006, 002, 000, 000, 000, 000,-002,-006, 127,
    127, 019, 002, 000, 000, 000, 000,-002,-019, 127,
    127, 126, 002, 000, 000, 000, 000,-002,-126, 127,
    127, 006, 002, 000, 000, 000, 000,-002,-006, 127,
    127, 007, 002, 000, 000, 000, 000,-002,-007, 127,
    127, 010, 002, 000, 000, 000, 000,-002,-010, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 127, 127, 127, 127, 127
  );
var
  r: tRoque;
begin
  with initiale do
  begin
    damier := cDamier;
    trait := 1;
    for r := e1g1 to e8c8 do
      roque[r] := true;
    passant[-1] := 0;
    passant[00] := 0;
    passant[+1] := 0;
    balance := 0;
  end;
  courante := initiale;
  demi := 0;
  profondeur := 3;
  maximale := 5;
end;
 
function ChaineDamier: string;
{$I ChaineDamier.inc}
var
  x, y: integer;
  c: char;
begin
  result := cChaineDamier;
  for x := 1 to 8 do
    for y := 1 to 8 do
    begin
      case Abs(courante.damier[10 * x + y]) of
        cNeant   : c := ' ';
        cPion    : c := 'P';
        cCavalier: c := 'C';
        cFou     : c := 'F';
        cTour    : c := 'T';
        cRoi     : c := 'R';
        cDame    : c := 'D';
      end;
      if courante.damier[10 * x + y] < cNeant then
        Inc(c, Ord('a') - Ord('A'));
      result[4 * x + 86 * (8 - y) + 132] := c;
    end;
end;
 
function CoupUtilisateur(aCoup: string): boolean;
var
  i: integer;
  copie: tPosition;
  coup, erreur: integer;
  a, b: integer;
begin
  aCoup[1] := Chr(Ord(aCoup[1]) - (Ord('a') - Ord('1')));
  aCoup[3] := Chr(Ord(aCoup[3]) - (Ord('a') - Ord('1')));
  Val(aCoup, coup, erreur);
  if erreur = 0 then
  begin
    a := coup div 100;
    b := coup mod 100;
    courante.GenereCoups;
    result := false;
    i := 1;
    with courante do
      while (i <= nombre) and not result do
        if coup = 100 * coups[i].a + coups[i].b then
          result := true
        else
          Inc(i);
    if result then
    begin
      copie := courante;
      copie.Deplace(a, b, cDame);
      copie.trait := -1 * copie.trait;
      if copie.Echec then
        result := false
      else
      begin
        courante.Deplace(a, b, cDame);
        Inc(demi);
      end;
    end;
  end
  else
    result := false;
end;
 
function ChaineCoup(const a, b: integer): string;
begin
  Str(100 * a + b, result);
  result[1] := Chr(Ord(result[1]) + Ord('0'));
  result[3] := Chr(Ord(result[3]) + ord('0'));
end;
 
function MeilleurCoup(const aNote: integer): integer;
var
  copie: tPosition;
  i, j: integer;
  maximum: integer;
  n: integer;
begin
  with courante do
  begin
    n := 0;
    for i := 1 to nombre do
      if coups[i].note = aNote then
      begin
        Inc(n);
        selection[n].a := coups[i].a;
        selection[n].b := coups[i].b;
        selection[n].note := 0
      end;
  end;
  maximum := Low(integer);
  result := 1;
  for i := 1 to n do
  begin
    copie := courante;
    with copie do
    begin
      if {copie.}IdentiqueInitiale(selection[i].a) then
      begin
        Inc(selection[i].note, 5);
        if damier[selection[i].a] * trait = cPion then
          Inc(selection[i].note, 2);
      end;
      if damier[selection[i].a] * trait = cRoi then
        Dec(selection[i].note, 10);
      if (demi < 32)
      and (damier[selection[i].a] * trait in [cPion, cFou, cCavalier]) then
        Inc(selection[i].note, 20);
      if (selection[i].a div 10 = 1)
      or (selection[i].a div 10 = 8)
      or (selection[i].a mod 10 = 1)
      or (selection[i].a mod 10 = 8) then
        Inc(selection[i].note, 2);
      if (selection[i].b div 10 = 1)
      or (selection[i].b div 10 = 8)
      or (selection[i].b mod 10 = 1)
      or (selection[i].b mod 10 = 8) then
        Dec(selection[i].note, 2);
    end;
    copie := courante;
    copie.Deplace(selection[i].a, selection[i].b, cDame);
    if copie.IdentiqueInitiale(selection[i].b) then
      Dec(selection[i].note, 10);
    copie.trait := -1 * copie.trait;
    copie.GenereOrdinaires;
    with copie do
    begin
      for j := 1 to nombre do
      begin
        Inc(selection[i].note);
        if damier[coups[j].b] <> cNeant then
          Inc(selection[i].note);
      end;
    end;
    copie.trait := -1 * copie.trait;
    copie.GenereOrdinaires;
    with copie do
    begin
      for j := 1 to nombre do
      begin
        Dec(selection[i].note);
        if damier[coups[j].b] <> cNeant then
          Dec(selection[i].note);
      end;
    end;
    if selection[i].note >= maximum then
    begin
      maximum := selection[i].note;
      result := i;
    end;
  end;
end;
 
procedure ChangeProfondeur(const aProfondeur, aMaximale: integer);
begin
  profondeur := aProfondeur;
  maximale := aMaximale;
end;
 
function CoupAutomate(var aDrapeau: integer): string;
var
  i: integer;
  e: boolean;
begin
  i := MeilleurCoup(courante.EvaluationR(courante.trait, 1, 32000));
  Inc(demi);
  e := courante.Echec;
  courante.Deplace(selection[i].a, selection[i].b, cDame);
  result := ChaineCoup(selection[i].a, selection[i].b);
  courante.trait := -1 * courante.trait;
  if courante.Echec then
  begin
    if e then
      aDrapeau := 3
    else
      aDrapeau := 2;
  end else
  begin
    courante.trait := -1 * courante.trait;
    if courante.Echec then
      aDrapeau := 1
    else
      aDrapeau := 0;
  end;
end;
 
function ExeName: string;
var
  aux: string;
begin
  aux := ExtractFileName(ParamStr(0));
  result := Copy(aux, 1, Pos('.', aux) - 1);
end;
 
var
  t: text;
  drapeau: integer;
  n: integer;
 
begin
  Assign(t, Concat(ExeName, '.txt'));
  Rewrite(t);
  Installe;
  n := 0;
  WriteLn(t, ChaineDamier);
  WriteLn(t);
  repeat
    Inc(n);
    Write(t, CoupAutomate(drapeau));
    WriteLn(t, ' ', drapeau);
    WriteLn(t);
    WriteLn(t, ChaineDamier);
    WriteLn(t);
  until n = 8;
  Close(t);
end.

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
 
// ChaineDamier.inc
 
const
  cChaineDamier =
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '|   | a | b | c | d | e | f | g | h |   |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 8 |   |   |   |   |   |   |   |   | 8 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 7 |   |   |   |   |   |   |   |   | 7 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 6 |   |   |   |   |   |   |   |   | 6 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 5 |   |   |   |   |   |   |   |   | 5 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 4 |   |   |   |   |   |   |   |   | 4 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 3 |   |   |   |   |   |   |   |   | 3 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 2 |   |   |   |   |   |   |   |   | 2 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '| 1 |   |   |   |   |   |   |   |   | 1 |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+'#13#10 +
  '|   | a | b | c | d | e | f | g | h |   |'#13#10 +
  '+---+---+---+---+---+---+---+---+---+---+';

**Roland Chastain** · 28/11/2013, 07h50

Voici une nouvelle fonction qui permet d'exporter la position courante dans un fichier HTML utilisant une police de caractères pour les échecs, en l'occurrence la police Chess Alfonso-X.

Les conditions de travail en sont nettement améliorées.

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
// Chess Alfonso-X
// True Type Font by Armando H. Marroquin
// http://www.enpassant.dk/chess/fonteng.htm
 
function ChaineDamierHtml: string;
const
  cChaineDamierHtml =
    '<p>'#13#10 +
    '!""""""""#<br>'#13#10 +
    '$tMvWlVmT%<br>'#13#10 +
    '$OoOoOoOo%<br>'#13#10 +
    '$ + + + +%<br>'#13#10 +
    '$+ + + + %<br>'#13#10 +
    '$ + + + +%<br>'#13#10 +
    '$+ + + + %<br>'#13#10 +
    '$pPpPpPpP%<br>'#13#10 +
    '$RnBqKbNr%<br>'#13#10 +
    '/(((((((()<br>'#13#10 +
    '</p>';
var
  x, y: integer;
  c: char;
begin
  result := cChaineDamierHtml;
  for x := 1 to 8 do
    for y := 1 to 8 do
    begin
      case courante.damier[10 * x + y] of
        cNeant   : c := ' ';
        cPion    : c := 'p';
        cCavalier: c := 'n';
        cFou     : c := 'b';
        cTour    : c := 'r';
        cDame    : c := 'q';
        cRoi     : c := 'k';
        -1 * cPion    : c := 'o';
        -1 * cCavalier: c := 'm';
        -1 * cFou     : c := 'v';
        -1 * cTour    : c := 't';
        -1 * cDame    : c := 'w';
        -1 * cRoi     : c := 'l';
      end;
      if (x + y) mod 2 = 1 then
        if courante.damier[10 * x + y] = cNeant then
          c := '+'
        else
          Dec(c, Ord('a') - Ord('A'));
      result[x + 16 * (8 - y) + 22] := c;
    end;
end;

**Roland Chastain** · 08/12/2013, 09h34

Bonjour !

Pour terminer le projet sur lequel je travaille (une mise à jour de JS-Echecs, pour Virtual Pascal), il me reste à écrire un petit programme qui ne ferait que générer les coups légaux, détecter les fins de partie, mais ne "jouerait" pas (puisque j'ai déjà un moteur, à savoir le programme que j'ai présenté dans les messages précédents).

Pour les listes de coups, je voudrais utiliser le type tStringList. J'aimerais bien avoir votre avis sur la façon d'appeler les méthodes Create et Free, et plus généralement sur l'organisation de mon objet tPosition. Faut-il ajouter une méthode Create pour tout l'objet, ou surcharger une méthode existante ?
D'habitude, quand j'utilise le type object, je ne me soucie pas de ce genre de choses, mais là je suis obligé d'y penser à cause de la liste.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
type
  tPosition = object
    damier: tDamier;
    trait: integer;
    roque: string[4];
    enPassant: string[2];
    demiCoups: integer;
    coup: integer;
    liste: tStringList;
    procedure Initialise;
    procedure GenereCoups;
  end;

P.-S. Voici la solution que j'ai trouvée. Est-ce que c'est correct ?

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
type
  tPosition = object
    damier: tDamier;
    trait: integer;
    roque: string[4];
    enPassant: string[2];
    demiCoups: integer;
    coup: integer;
    liste: tStringList;
    constructor Cree; // <--
    destructor Libere; // <--
    procedure Initialise;
    procedure GenereCoups;
  end;
 
implementation
 
constructor tPosition.Cree;
begin
  liste := tStringList.Create;
end;
 
destructor tPosition.Libere;
begin
  liste.Free;
end;

Voici ce que ça donne dans le programme principal :

Code :

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

1
2
3
4
5
6
7
8
9
10
  //position.liste := tStringList.Create;
  position.Cree;
 
  position.Initialise;
  position.GenereCoups;
 
  WriteLn(position.liste.text);
 
  //position.liste.Free;
  position.Libere;

P.-P.-S. Bon, ça paraît fonctionner mais quelle différence cela ferait-il si à la place du constructor et du destructor je mettais des procédures ordinaires ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
//constructor tPosition.Cree;
procedure tPosition.Cree;
begin
  liste := tStringList.Create;
end;
 
//destructor tPosition.Libere;
procedure tPosition.Libere;
begin
  liste.Free;
end;

**Roland Chastain** · 11/12/2013, 18h52

Bonjour !

Mon unité est pratiquement finie. Je pense avoir trouvé une architecture acceptable : un type tPosition, contenant deux listes (une seule suffirait peut-être), deux variables globales de ce type (l'une représentant l'état actuel du jeu, l'autre l'état du jeu après le coup), plus une autre liste contenant les coups légaux, plus une procédure pour remplir la liste.

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
type
  tPosition = object
    damier: tDamier;
    trait: integer;
    roque: string[4];
    enPassant: string[2];
    demiCoups: integer;
    coup: integer;
    liste1: tStringList;
    liste2: tStringList;
    procedure Initialise;
    procedure GenereCoups(const aCouleur: integer; const aListe: tStringList; const aTousLesCoups: boolean);
    procedure GenereRoque(const c: char; const aListe: tStringList);
    function Echec: boolean;
    function EchecRoque(c: char): boolean;
    procedure Supprime(const c: char);
    procedure Joue(const aCoup: string; const aPromotion: integer);
    function FEN: string;    
  end;
 
var
  position1, position2: tPosition;
  liste: tStringList;
 
procedure GenereCoupsLegaux;

Je cherche toujours une façon correcte d'appeler les méthodes Create et Free de mes listes. En attendant, je les appelle une par une depuis le programme principal. Ce n'est pas très joli et d'ailleurs j'obtiens une erreur lorsque je libère les listes. Sauriez-vous d'où vient cette erreur ?

**M.Dlb** · 12/12/2013, 09h38

Salut,

Normalement, tu devrais surcharger les méthodes Create et Free, en faisant à l'intérieur des appels aux méthodes parentes. Par exemple:

Code :

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

1
2
3
4
5
constructor TPosition.Create;
begin
  if inherited Create then Fail;
  Liste := TStringList.Create;
end;

**Roland Chastain** · 12/12/2013, 18h47

Merci pour la réponse.

J'obtiens une erreur sur la ligne contenant le mot-clé inherited : "Error 119: No inherited methods are accessible here" (Virtual Pascal), "Error: identifier idents no member "Create"" (Free Pascal).

En supprimant cette ligne, ça fonctionne, mais j'ai toujours un problème au moment de libérer les listes. Peut-être faudrait-il que je modifie la déclaration de mon type. J'aurais dû mettre cela au point avant de me lancer dans l'écriture du programme.

**M.Dlb** · 13/12/2013, 09h38

Ne connaissant pas Virtual Pascal, je ne pourrai pas tester, mais le compilateur semble indiquer qu'il n'y a pas de constructor Create pour le type TObject (ce qui est le cas avec Delphi).

Dans ce cas, l'utilisation d'un constructor ayant un autre nom est valable (constructor Cree).

Aussi, il est possible que le constructor ait un autre nom. Par exemple pour TP, il s'appelait Init, et le destructor Done. A vérifier dans la doc Virtual Pascal

**Roland Chastain** · 13/12/2013, 09h38

J'ai essayé de reprendre le problème depuis le début.

Au départ j'avais un objet de type object que j'utilisais le plus simplement du monde.

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
program TPosition1;
 
type
  tPosition = object
    chaine: string;
    procedure Saisie;
  end;
 
procedure tPosition.Saisie;
begin
  ReadLn(chaine);
end;
 
var
  position: tPosition;
 
begin
  position.Saisie;
end.

J'ai voulu inclure dans cet objet une liste de chaînes.

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
program TPosition2;
 
uses
  Classes;
 
type
  tPosition = object
    liste: tStringList;
    procedure Saisie;
  end;
 
procedure tPosition.Saisie;
var
  chaine: string;
begin
  ReadLn(chaine);
  liste.Add(chaine);
end;
 
var
  position: tPosition;
 
begin
  position.liste := tStringList.Create;
  position.Saisie;
  position.liste.Free;
end.

Le problème se posait alors de savoir où appeler les méthodes Create et Free, d'autant que dans mon programme j'ai un deuxième objet qui contient deux variables du premier type.

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
program TPosition3;
 
uses
  Classes;
 
type
  tPosition = object
    liste: tStringList;
    procedure Saisie;
  end;
 
  tPositionTemps = object
    actuelle, suivante: tPosition;
  end;
 
procedure tPosition.Saisie;
var
  chaine: string;
begin
  ReadLn(chaine);
  liste.Add(chaine);
end;
 
var
  positionTemps: tPositionTemps;
 
begin
  positionTemps.actuelle.liste := tStringList.Create;
  positionTemps.actuelle.Saisie;
  positionTemps.actuelle.liste.Free;
end.

A ce moment-là, j'hésite entre deux possibilités. Est-ce que je conserve telle quelle la déclaration de mes types ? Et dans ce cas, comment régler le problème des listes ? Ou est-ce que je modifie la déclaration des types ? Mais dans ce cas, pour mettre quoi à la place d'object ? Je vois que le langage offre plusieurs possibilités, entre lesquelles je ne vois pas trop quoi choisir. Et pendant ce temps, mon programme est en train de refroidir.

Pour le moment, voici ce que j'ai trouvé. Il semble que ça marche, mais si vous avez des suggestions je les écouterais volontiers.

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
program TPosition4;
 
uses
  Classes;
 
type
  tPosition = class//object
    liste: tStringList;
    constructor Create;
    procedure Free;
    procedure Saisie;
  end;
 
  tPositionTemps = class//object
    actuelle, suivante: tPosition;
    constructor Create;
    procedure Free;
  end;
 
constructor tPosition.Create;
begin
  liste := tStringList.Create;
end;
 
procedure tPosition.Free;
begin
  liste.Free;
end;
 
procedure tPosition.Saisie;
var
  chaine: string;
begin
  ReadLn(chaine);
  liste.Add(chaine);
end;
 
constructor tPositionTemps.Create;
begin
  actuelle := tPosition.Create;
  suivante := tPosition.Create;
end;
 
procedure tPositionTemps.Free;
begin
  actuelle.Free;
  suivante.Free;
end;
 
var
  positionTemps: tPositionTemps;
 
begin
  positionTemps := tPositionTemps.Create;
  positionTemps.actuelle.Saisie;
  positionTemps.Free;
end.

Projet d'un programme de jeu d'échecs

Contribuez Pascal

Discussions similaires

Partager

Partager