Discussion :

[Roland Chastain]

oui, sinon je t'avais donné la formule avec un "and" binaire et non booléen.

mais avec une petite erreur, la valeur n'est pas 1 mais "1 shl fig", qu'on testera simplement > 0

Code :

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

1
2
 
  if image[y, x] and (1 shl fig) > 0 then

Vu !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
program ex;
 
var
  a, b, c: byte;
 
begin
  a := 15;      // 00001111
  b := 1 shl 3; // 00001000
  c := a and b; // 00001000
  writeLn(c);   // 8
  readLn;
end.

Merci pour ton astuce. Je suis bien content de ce petit programme.

[Roland Chastain]

Bonjour !

Voici une "démo" qui est l'état actuel de mon projet.

L'ordinateur joue contre lui-même. La partie se termine (je vous rassure) à la suite de 50 coups joués sans prise ni pion déplacé.

J'ai trouvé un début d'algorithme pour l'évaluation des coups. Il est encore très imparfait mais j'ai bon espoir d'en faire quelque chose.

[EDIT]

Après de minimes modifications, j'ai eu l'agréable surprise de pouvoir compiler le programme sous Delphi 7.

[Simicro]

Même si dans un autre topic tu disais avoir du "retard" pour avoir commencé récemment le Pascal (comme moi), je trouve que t'assures avec ton programme d'échecs Peut-être devrais-tu ajouter une option pour voir les mouvements coup par coup sinon ça va trop vite Mais je comprends aussi que ce soit fascinant de voir l'ordi jouer contre lui même à toute vitesse !

[Roland Chastain]

Même si dans un autre topic tu disais avoir du "retard" pour avoir commencé récemment le Pascal (comme moi), je trouve que t'assures avec ton programme d'échecs Peut-être devrais-tu ajouter une option pour voir les mouvements coup par coup sinon ça va trop vite Mais je comprends aussi que ce soit fascinant de voir l'ordi jouer contre lui même à toute vitesse !

Merci, Simicro.

C'est un montage provisoire que j'ai fait pour voir si tout fonctionnait. J'espère proposer bientôt quelque chose de mieux.

En attendant, pour la pause entre les coups, il suffit de "décommenter" ces lignes du fichier "tablier.pas" :

Code :

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

1
2
3
4
5
6
  //repeat
    //
    //delay(10);
    //
  //until keyPressed or closeGraphRequest;
  //

ou même de "décommenter" seulement le delay().

[Roland Chastain]

Voici le dernier état de mon programme.

Pour jouer tapez par exemple "e2e4".

Autres commandes :

"init" commencer une nouvelle partie
"play" passer la main à l'ordinateur
"exit" quitter le programme

[EDIT]

Correction d'une erreur importante et diverses améliorations.

[EDIT]

Ajouté une directive de compilation qui permet de cacher ou de montrer la console. Quand la console est visible, on peut y lire la note des coups.

Code :

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

1
2
3
4
5
{$DEFINE DEV}
//{$UNDEF DEV}
{$IFDEF DEV}
{$APPTYPE CONSOLE}
{$ENDIF}

Ajouté aussi un petit livre d'ouvertures.

[dany135]

bonjour!

j'ai regardé ton travail , qui est pas mal du tout
Je développe moi même un jeu d'échecs en C a mes moments perdus , je n'ai pas écrit de GUI , (j'utilise winboard http://www.tim-mann.org/xboard.htmlou arena http://www.playwitharena.com/ ) qui permet de faire jouer deux moteurs d'échecs l'un contre l'autre , utile pour tester!
Il faut programmer le protocole winboard (http://www.open-aurec.com/wbforum/Wi...gine-intf.html) ,je ne sais pas si c'est possible en pascal , je ne connais pas ce langage
Mais ensuite ça permet de jouer contre d'autres moteurs et de savoir où on en est du niveau

Pour info , mes deux programmes d'échecs Jars et yoda on joués plusieurs tournois ici : http://www.open-aurec.com/chesswar/
Les tournois sont en broadcast et peuvent être suivis en direct grace a TLCV
(http://home.pacific.net.au/~tommyinoz/tlcv.html)

Hélas le gars de open aurec a décidé de stopper ses tournois en partie a cause des histoires de clones

Enfin voila j'espère que ça t'aura intéressé , si tu veux des idées pour l'IA je peux t'aider un peu peut être
bye!

[Roland Chastain]

Bonsoir !

Merci pour tes encouragements.

Je connais en tant qu'utilisateur le système des protocoles WinBoard et UCI. (J'aime bien l'interface Tarrasch.) Je sais aussi que cela se fait en Pascal. Le sujet m'intéresse mais à vrai dire je n'en suis pas encore là. Pour le moment mon ambition est d'écrire un programme simple, qui produise un jeu présentable, et qui ne contienne aucune erreur.

J'ai trouvé un moteur qui marche assez bien. Je cherche à changer la façon de le commander. Pour le moment tout tient dans deux procédures :

Code :

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

1
2
3
  repeat
    if entreeUtilisateur then coupOrdinateur;
  until quitter;

Ça fonctionne mais il faut trouver le moyen de savoir quand même ce qui se passe à l'intérieur des procédures, ne serait-ce que pour pouvoir notifier correctement à l'utilisateur les différents événements.

Puisque tu pratiques le protocole WinBoard, est-ce que tu pourrais décrire sommairement l'interaction entre l'interface et le moteur ? Les ordres que le moteur doit pouvoir exécuter, le format des données échangées... Si tu dois poster un exemple de code en C, personne je crois n'y verra d'inconvénient.

[dany135]

Bonjour !

Voilà je t'avais mis le lien pour le protocole winboard : http://www.open-aurec.com/wbforum/Wi...ne-intf.html#9
mais en gros on a une boucle infinie dans le main() qui gère les commandes envoyées et reçues :
extrait du main() :

Code C :

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
int main()
{
    char s[256];
    int m;
    int valide;
    int profondeur;
 
    printf("ds main 1 %d\n",nb_coups);
 
    printf("--------------------------------\n");
    printf("      YODA version %2.3f\n", VERSION);
    printf(" Dany ANULLIERO   22/05/2012\n");
    printf("--------------------------------\n\n");
 
    init();
    affiche_echiquier();
 
    for (;;)
    {
        if (side == couleur_YODA)
        {
            m = YODA_joue(1);
            if(m == -1)
            {
                couleur_YODA = VIDE;
                continue;
            }
            mm[nb_coups] = m;
            jouer_coup(m);
            printf("move %6s\n", coord_cases(pile_coups[m].dep , pile_coups[m].arr , pile_coups[m].type,
                                    pile_coups[m].piece_promue));
            affiche_echiquier();
            affiche_resultat();
            continue;
        }
 
 
        printf("<--- YODA attend votre coup --->\n");
        if (scanf("%s", s) == EOF)
            return 0;
        if (!strcmp(s, "analyze"))
        {
            couleur_YODA = side;
            temps_max = 1000000000;
            temps_max *= 10;
            temps_max /= 30;
            prof_max = 100;
            continue;
        }
        if (!strcmp(s, "on"))
        {
            couleur_YODA = side;
            continue;
        }

Llorsque tu passes du mode console au mode GUI , j'ai une fonction xboard(), presque jumelle de main() qui prend la main

Code C :

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

1
2
3
4
5
6
 
if (!strcmp(s, "xboard"))
        {
            xboard();
            break;
        }

Le moteur envoie son coup joué avec le mot clé move qu'xboard reconnaît

Extrait de la fonction xboard():

Code C :

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
 
void xboard()
{
    char line[256], command[256];
    int m;
    int post = 0;
    int valide;
    int analyze_mode = FAUX;
 
    signal(SIGINT, SIG_IGN);
    printf("\n");
    init();
    gen_coups();
    couleur_YODA = VIDE;
    for (;;)
    {
        fflush(stdout);
        if (side == couleur_YODA)
        {
            m = YODA_joue(post);
            if(m == -1)
            {
                couleur_YODA = VIDE;
                continue;
            }
            printf("move   %6s\n", coord_cases(pile_coups[m].dep , pile_coups[m].arr , pile_coups[m].type,
                                    pile_coups[m].piece_promue));
            jouer_coup(m);
            affiche_resultat();
            continue;
        }
        if (!fgets(line, 256, stdin))
            return;
        if (line[0] == '\n')
            continue;
        sscanf(line, "%s", command);
        if (!strcmp(command, "xboard"))
            continue;
        if (!strcmp(command, "protover"))
        {
            printf("feature done=0\n");
            printf("feature myname=\"YODA %s x64\"\n",version);
            printf("feature done=1\n");
            continue;
        }

C'est la fonction signal qui interrompt le moteur mode console et fait prendre la main à la GUI en gros.

Quand tu est sous arena tu as la fenêtre debug qui affiche tout les échanges entre la GUI et le moteur :
extrait d'un debug d'arena :

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
 
USERNAME=dany
USERPROFILE=C:\Users\dany
windir=C:\Windows
Font Arena Chess Figurine MISSING
 
2012-09-17 07:31:30,142**----------New game---2012-09-17 07:31:30,142 lun. -------------
2012-09-17 07:31:30,404**Loading  1
2012-09-17 07:31:35,112**----------New game---2012-09-17 07:31:35,112 lun. -------------
2012-09-17 07:32:00,935********======== Tournament 1 ========
2012-09-17 07:32:01,273********
2012-09-17 07:32:01,273********Pairing 1/1: YODA_2  -  Standersen_X64
2012-09-17 07:32:01,289*1*--------------------------Starting engine 1 YODA_2--------------------------
2012-09-17 07:32:01,294*1*Configured Engine 1 Type:   WB2
2012-09-17 07:32:01,295*1*Engine 1 dir: D:\ARENA\Engines\YODA
2012-09-17 07:32:01,295*1*Engine 1 commandline: D:\ARENA\Engines\YODA\YODA_2.exe 
2012-09-17 07:32:01,598*1*Engine 1 ProcessID: 5196
2012-09-17 07:32:01,598*1*Engine 1 Prio:32 ThreadPrio:0
2012-09-17 07:32:01,599-->1:xboard
2012-09-17 07:32:01,599-->1:protover 2
2012-09-17 07:32:01,634<--1:--------------------------------
2012-09-17 07:32:01,634<--1:      YODA version 1.344
2012-09-17 07:32:01,634<--1: Dany ANULLIERO   22/05/2012
2012-09-17 07:32:01,771<--1:--------------------------------
2012-09-17 07:32:01,773<--1:8  t c f d r f c t
2012-09-17 07:32:01,774<--1:7  p p p p p p p p
2012-09-17 07:32:01,774<--1:6  . . . . . . . .
2012-09-17 07:32:01,794<--1:5  . . . . . . . .
2012-09-17 07:32:01,794<--1:4  . . . . . . . .
2012-09-17 07:32:01,814<--1:3  . . . . . . . .
2012-09-17 07:32:01,814<--1:2  P P P P P P P P
2012-09-17 07:32:01,834<--1:1  T C F D R F C T
2012-09-17 07:32:01,834<--1:   a b c d e f g h 
2012-09-17 07:32:01,854<--1:Nombre de coups joues   :   0
2012-09-17 07:32:01,854<--1:Couleur qui joue        :   B
2012-09-17 07:32:01,874<--1:Stage                   :  0
2012-09-17 07:32:01,874<--1:Roques blancs           :   KQ
2012-09-17 07:32:01,894<--1:Roques noirs            :   kq
2012-09-17 07:32:01,894<--1:Regle des 50 coups      :   0 
2012-09-17 07:32:01,914<--1:Regles des 3 repetitions:
2012-09-17 07:32:01,914<--1:Evaluation materielle   :   4135     4135
2012-09-17 07:32:01,934<--1:Evaluation statique     :      0
2012-09-17 07:32:01,934<--1:Hashcode de la position : 600c118577551c8
2012-09-17 07:32:01,954<--1:Index dans TT           : 348616
2012-09-17 07:32:01,974<--1:Positions testees       : 0 
2012-09-17 07:32:01,994<--1:Positions trouvees      : 0 
2012-09-17 07:32:02,014<--1:Positions sauvees       : 0 
2012-09-17 07:32:02,014<--1:champs de bits apres coup : 65280   71776119061217280
2012-09-17 07:32:02,034<--1:<--- YODA attend votre coup --->
2012-09-17 07:32:02,034<--1:feature done=0
2012-09-17 07:32:02,034-->1:accepted done
2012-09-17 07:32:02,035<--1:feature myname="YODA 1.344 x64"
2012-09-17 07:32:02,055<--1:feature done=1
2012-09-17 07:32:02,055-->1:accepted done
2012-09-17 07:32:02,055<--1:Illegal move: accepted done
2012-09-17 07:32:02,075<--1:Illegal move: accepted done
2012-09-17 07:32:02,176-->1:new
2012-09-17 07:32:02,176-->1:random
2012-09-17 07:32:02,176-->1:level 0 5 0
2012-09-17 07:32:02,176-->1:post
2012-09-17 07:32:02,177-->1:hard
2012-09-17 07:32:02,177-->1:easy
2012-09-17 07:32:02,177-->1:computer
2012-09-17 07:32:02,299*2*----------------------Starting engine 2 Standersen_X64----------------------
2012-09-17 07:32:02,304*2*Configured Engine 2 Type:   WB2
2012-09-17 07:32:02,305*2*Engine 2 dir: D:\ARENA\Engines\STANDERSEN\standersen_131c_rev2_ja\x64
2012-09-17 07:32:02,305*2*Engine 2 commandline: D:\ARENA\Engines\STANDERSEN\standersen_131c_rev2_ja\x64\standersen_X64.exe -h 10
2012-09-17 07:32:02,608*2*Engine 2 ProcessID: 3532
2012-09-17 07:32:02,608*2*Engine 2 Prio:32 ThreadPrio:0
2012-09-17 07:32:02,609-->2:xboard
2012-09-17 07:32:02,609-->2:protover 2
2012-09-17 07:32:02,644<--2:Welcome to StAndersen v1.31 JA for X64
2012-09-17 07:32:02,644<--2:Author: Erik Robertsson 
2012-09-17 07:32:02,644<--2:Contact via email: St.Andersen@codenet.se
2012-09-17 07:32:02,781<--2:Hashsize: 204800KB (8388608 entries)
2012-09-17 07:32:02,781<--2:PawnHashsize: 65536 (8388608 entries)
2012-09-17 07:32:02,782<--2:StAndersen command summary
2012-09-17 07:32:02,802<--2:---------------------------------------------------------------
2012-09-17 07:32:02,822<--2:b2b3     move from b2 to b3      quit     exit StAndersen
2012-09-17 07:32:02,842<--2:a7a8q    promote pawn to queen   bd       display board
2012-09-17 07:32:02,862<--2:o-o      castle king side        switch   sides with computer
2012-09-17 07:32:02,881<--2:o-o-o    castle queen side       white    you play white
2012-09-17 07:32:02,882<--2:sd n     set search depth to n   black    you play black
2012-09-17 07:32:02,882<--2:random   randomize play          new      start new game
2012-09-17 07:32:02,882<--2:beep     toggle sound            mem      display memory status
2012-09-17 07:32:02,882<--2:force    twoplayer mode          legal    list the legal moves
2012-09-17 07:32:02,883<--2:undo     takeback a move         load     load a FEN/EPD position
2012-09-17 07:32:02,883<--2:test     perform a EPD test
2012-09-17 07:32:02,883<--2:---------------------------------------------------------------
2012-09-17 07:32:02,883<--2:feature setboard=0 myname="StAndersen 1.31 JA" ping=1 playother=0 san=0 usermove=0 time=1 draw=0 sigint=0 sigterm=0 reuse=1 analyze=1 colors=0 ics=1 name=0 pause=0 done=1
2012-09-17 07:32:02,884-->2:accepted setboard
2012-09-17 07:32:02,884-->2:accepted ping
2012-09-17 07:32:02,884-->2:accepted playother
2012-09-17 07:32:02,884-->2:accepted san
2012-09-17 07:32:02,884-->2:accepted usermove
2012-09-17 07:32:02,885-->2:accepted time
2012-09-17 07:32:02,885-->2:accepted draw
2012-09-17 07:32:02,885-->2:accepted sigint
2012-09-17 07:32:02,885-->2:accepted sigterm
2012-09-17 07:32:02,885-->2:accepted reuse
2012-09-17 07:32:02,885-->2:accepted analyze
2012-09-17 07:32:02,886-->2:accepted colors
2012-09-17 07:32:02,886-->2:accepted ics
2012-09-17 07:32:02,886-->2:accepted name
2012-09-17 07:32:02,886-->2:accepted pause
2012-09-17 07:32:02,886-->2:accepted done
2012-09-17 07:32:02,983-->1:?
2012-09-17 07:32:02,983-->2:?
2012-09-17 07:32:02,983<--1:Illegal move: ?
2012-09-17 07:32:03,084-->2:new
2012-09-17 07:32:03,085-->2:random
2012-09-17 07:32:03,085-->2:ics -
2012-09-17 07:32:03,085-->2:level 0 5 0
2012-09-17 07:32:03,085-->2:post
2012-09-17 07:32:03,085-->2:hard
2012-09-17 07:32:03,086-->2:easy
2012-09-17 07:32:03,086-->2:ping 3
2012-09-17 07:32:03,206<--2:pong 3
2012-09-17 07:32:03,209-->2:computer
2012-09-17 07:32:03,269-->2:ics -
2012-09-17 07:32:03,358-->1:easy
2012-09-17 07:32:03,358-->2:easy
2012-09-17 07:32:03,359********Round 1 of 10: YODA_2  -  Standersen_X64
2012-09-17 07:32:03,370**----------New game---2012-09-17 07:32:03,370 lun. -------------
2012-09-17 07:32:03,370-->1:level 0 5 0
2012-09-17 07:32:03,370-->1:new
2012-09-17 07:32:03,371-->1:random
2012-09-17 07:32:03,371-->1:level 0 5 0
2012-09-17 07:32:03,372-->1:post
2012-09-17 07:32:03,372-->1:hard
2012-09-17 07:32:03,372-->1:easy
2012-09-17 07:32:03,372-->1:computer
2012-09-17 07:32:03,373-->2:level 0 5 0
2012-09-17 07:32:03,373-->2:new
2012-09-17 07:32:03,373-->2:random
2012-09-17 07:32:03,373-->2:ics -
2012-09-17 07:32:03,373-->2:level 0 5 0
2012-09-17 07:32:03,373-->2:post
2012-09-17 07:32:03,373-->2:hard
2012-09-17 07:32:03,374-->2:easy

[Roland Chastain]

Bonsoir et bonne année !

Je reviens à mon projet. En me promenant sur le site d'Ed Schröder (qui a été champion du monde plusieurs années consécutives avec le moteur Rebel) je suis tombé sur cette page.

Le livre d'ouvertures de Rebel (renommé Pro Deo) est offert avec le code source (en C) et même avec une unité Delphi ! Mon sang n'a fait qu'un tour en lisant cela.

Si le sujet vous intéresse, vos contributions seront les bienvenues. Je n'ai aucune expérience de l'utilisation d'une "dll". Je ne connais pas le C. Je ne sais pas précisément comment le livre est fait.

P.-S. Merci encore à dany135.

[Roland Chastain]

J'espère proposer un peu plus tard un exemple de programme utilisant la dll dont j'ai parlé ci-dessus. Aujourd'hui je voulais vous faire part d'une expérience instructive (du moins le fut-elle pour moi).

J'ai comparé deux façons de convertir des coordonnées : d'une part avec une procédure, de l'autre avec une table préalablement fabriquée. Or avec la table c'est beaucoup plus rapide, et je me demande si mon programme ne gagnerait pas à utiliser autant que possible des tables plutôt que des fonctions.

Voici le programme qui fabrique le fichier "table.inc" :

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
program tables;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
procedure iToXY(const i: integer; var x: integer; var y: integer);
begin
  x := i div 10;
  y := i mod 10;
end;
 
procedure GenereTable;
var
  i, x, y: integer;
  t: text;
begin
  Assign(t, 'table.inc');
  Rewrite(t);
  WriteLn(t, 'const iToXY: array[-10..109, 0..1] of integer = (');
  for i := -10 to 109 do
  begin
    iToXY(i,x,y);
    Write(t, '  ('+IntToStr(x)+','+IntToStr(y)+')');
    if i < 109 then WriteLn(t, ',');
  end;
  WriteLn(t, ');');
  Close(t);
end;
 
begin
 {WriteLn(-10 div 2); // -5}
  GenereTable;
  WriteLn('Appuyez sur ENTREE...');
  ReadLn;
end.

Et voici le test :

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
program compare;
 
{$APPTYPE CONSOLE}
 
uses
  Windows;
 
procedure proc_iToXY(const i: integer; var x: integer; var y: integer);
begin
  x := i div 10;
  y := i mod 10;
end;
 
{$I table.inc}
 
var
  A, B: Cardinal;
  i, x, y: Integer;
  rpt: Integer;
 
begin
  A := GetTickCount;
  for rpt := 0 to 99999 do for i := -10 to 109 do
    proc_iToXY(i,x,y);
  B := GetTickCount;
  WriteLn('Premiere methode (procedure) : ', B-A, ' ms');
 
  A := GetTickCount;
  for rpt := 0 to 99999 do for i := -10 to 109 do
  begin
    x := iToXY[i, 0];
    y := iToXY[i, 1];
  end;
  B := GetTickCount;
  WriteLn('Seconde methode (table) : ', B-A, ' ms');
 
  ReadLn;
end.

[Paul TOTH]

oui tout à fait, c'est quelque chose de bien connu des demomakers

par exemple le calcul d'un sinus ou d'un cosinus est quelque chose de relativement lent, il n'est donc pas rare de voir une table de sinus précalculée (pas besoin qu'elle soit en dur, le remplissage du tableau se fait au lancement du programme), et au lieu de travailler en degrés ou radians, on travail sur un entier qui représente un "pas" dans la table.

Exemple:

Code :

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

1
2
3
4
5
6
7
8
 
var
  Sinus: array[0..9] of Single; // sinus de 0 à 90° par pas de 10°
  Index: Integer;
begin
  for Index := 0 to 9 do
   Sinus[Index] := Sin(Index * 10 * PI/180);
end;

[Roland Chastain]

Merci Paul pour l'exemple. Effectivement, il n'est pas nécessaire d'écrire les valeurs sur le papier.

Je suis tombé tout à l'heure sur un site qui a l'air très intéressant : c'est une présentation détaillée (en anglais) d'un programme d'échecs appelé micro-Max, qui a la particularité de tenir dans une centaine de lignes ! Et avec ça il paraît qu'il joue bien !

On peut avoir un exécutable Windows sur cette page. Le programme (dont l'auteur propose plusieurs versions) est écrit en C.

Si quelqu'un qui connaît le C voulait faire une adaptation en Pascal, ce serait magnifique. Moi je veux bien essayer, mais je n'y connais rien. En même temps, cent lignes, ça doit être faisable.

Ce qui est intéressant dans ce programme, c'est que tout en étant petit, il a toutes les fonctions standard d'un programme d'échecs.

[M.Dlb]

Oui c'est intéressant, pour l'aspect challenge, mais c'est absolument imbitable même pour un programmeur chevronné de C. Il faut vraiment plonger dans les internes du code et dans la pensée du programmeur... Autrement dit, il vaut mieux passer (peut-être plus) du temps sur un code bien écrit et formalisé que sur un tel code, sauf si on veut se faire des noeuds au cerveau

[Roland Chastain]

Merci pour la réponse. Ne pourrait-on pas traduire le code même sans le comprendre dans un premier temps, en remplaçant une à une les opérations ?

A noter quand même qu'il y a une page sur le site où la signification de toutes les variables est donnée.

[Paul TOTH]

Merci Paul pour l'exemple. Effectivement, il n'est pas nécessaire d'écrire les valeurs sur le papier.

Je suis tombé tout à l'heure sur un site qui a l'air très intéressant : c'est une présentation détaillée (en anglais) d'un programme d'échecs appelé micro-Max, qui a la particularité de tenir dans une centaine de lignes ! Et avec ça il paraît qu'il joue bien !

On peut avoir un exécutable Windows sur cette page. Le programme (dont l'auteur propose plusieurs versions) est écrit en C.

Si quelqu'un qui connaît le C voulait faire une adaptation en Pascal, ce serait magnifique. Moi je veux bien essayer, mais je n'y connais rien. En même temps, cent lignes, ça doit être faisable.

Ce qui est intéressant dans ce programme, c'est que tout en étant petit, il a toutes les fonctions standard d'un programme d'échecs.

Tiens, j'ai commencé mais c'est fatiguant à lire le C et je n'ai pas en tête la précédence des opérateurs C (qui n'est pas la même qu'en Pascal)... Cette expression (t&k|p<3&!(r&7)!=!t) a eu raison de moi.

J'ai doublé les lettres majuscules car en C "a <> A" ça devient "a <> AA" en Pascal. Les #define permettent aussi bien de définir une constante qu'une fonction "inline" voire un code spécifique, par exemple U est une constante mais W() défini un WHILE, F une boule FOR, etc.

W() est remplacé par un while W1 (W2, W3...) où Wx est une fonction booléenne car le code C mélange affectation, incrémentation et comparaison, ce que Pascal ne sait pas faire.

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
 
program microMax;
{$APPTYPE CONSOLE}
(***************************************************************************/
/*                               micro-Max,                                */
/* A chess program smaller than 2KB (of non-blank source), by H.G. Muller  */
/***************************************************************************/
/* version 3.2 (2000 characters) features:                                 */
/* - recursive negamax search                                              */
/* - quiescence search with recaptures                                     */
/* - recapture extensions                                                  */
/* - (internal) iterative deepening                                        */
/* - best-move-first 'sorting'                                             */
/* - a hash table storing score and best move                              */
/* - full FIDE rules (expt minor ptomotion) and move-legality checking     *)
 
// Delphi Translation (c)2013 by Paul TOTH http://www.execute.re
 
//#define F(I,S,N) for(I=S;I<N;I++)
//#define W(A) while(A)
//#define K(A,B) *(int*)(T+A+(B&8)+S*(B&7))
//#define J(A) K(y+A,b[y])-K(x+A,u)-K(H+A,t)
 
//#define U 16777224
const U = 16777224;
 
//struct _ {int K,V;char X,Y,D;} A[U];           /* hash table, 16M+8 entries*/
type
  _ = record
    K, V   : Integer;
    X, Y, D: Byte;
  end;
var
  AA: array[0..U-1] of _;
 
//int V=112,M=136,S=128,I=8e4,C=799,Q,N,i;       /* V=0x70=rank mask, M=0x88 */
const
  VV = 112;
  MM = 136;
  SS = 128;
  II = 8e4;
  CC = 799;
var
  QQ, NN, i: Integer;
 
//char O,K,L,
var
  OO, KK, LL: Byte;
 
//w[]={0,1,1,3,-1,3,5,9},                        /* relative piece values    */
const
  w: array[0..7] of ShortInt = (0, 1, 1, 3, -1, 3, 5, 9);
 
//o[]={-16,-15,-17,0,1,16,0,1,16,15,17,0,14,18,31,33,0, /* step-vector lists */
//     7,-1,11,6,8,3,6,                          /* 1st dir. in o[] per piece*/
//     6,3,5,7,4,5,3,6},                         /* initial piece setup      */
const
  o : array[0..31] of ShortInt = (
    -16, -15, -17, 0 ,1, 16, 0, 1, 16, 15, 17, 0, 14, 18, 31, 33, 0,
    7, -1, 11, 6, 8, 3, 6,
    6, 3, 5, 7, 4, 5, 3, 6
  );
 
 
//b[129],                                        /* board: half of 16x8+dummy*/
var
  b: array[0..128] of Integer;
 
//T[1035],                                       /* hash translation table   */
var
  TT : array[0..1034] of Integer;
 
//n[]=".?+nkbrq?*?NKBRQ";                        /* piece symbols on printout*/
const
  n = '??+nkbrq?*?NKBRQ';
 
//D(k,q,l,e,J,Z,E,z,n)    /* recursive minimax search, k=moving side, n=depth*/
function D(k,q,l,e,JJ,ZZ,EE,z,n: Integer): Integer;
//int k,q,l,e,J,Z,E,z,n;  /* (q,l)=window, e=current eval. score, E=e.p. sqr.*/
{                       /* e=score, z=prev.dest; J,Z=hashkeys; return score*/
}
var
// int j,r,m,v,d,h,i=9,F,G;
  j, r, m, v, d, h, i, FF, GG: Integer;
// char t,p,u,x,y,X,Y,H,B;
  t, p, u, x, y, XX, YY, HH, BB: Byte;
// struct _*a=A;
  a : ^_;
 
  function W1: Boolean;
  begin
  // W((h=A[++j].K)&&h-Z&&--i);
    Inc(j);
    Dec(i);
    h := AA[j].K;
    Result := (h <> 0) and (h - ZZ <> 0) and (i <> 0);
  end;
 
  function W2: Boolean;
  begin
  // W(d++<n|z==8&N<1e7&d<98)
    Result := (d < n or z) = (8 and NN < 1e7) and (d < 98);
    Inc(d);
  end;
 
  function W3: Boolean;
  begin
    // W(r=p>2&r<0?-r:-o[++j])
    if (p > 2 and r < 0) then
      r := -p
    else begin
      Inc(j);
      r := -o[j];
    end;
  end;
 
label
  A_;
 
begin
  i := 9;
  a := @AA;
//                                               /* lookup pos. in hash table*/
// j=(k*E^J)&U-9;                                /* try 8 consec. locations  */
  j := (k * EE  xor JJ) and UU - 9;
// W((h=A[++j].K)&&h-Z&&--i);                    /* first empty or match     */
  while W1 do
  begin
// a+=i?j:0;                                     /* dummy A[0] if miss & full*/
    if i <> 0 then
      Inc(a, j);
// if(a->K)                                      /* hit: pos. is in hash tab */
  if a.K <> 0 then
  begin
 {d=a->D;v=a->V;X=a->X;                        /* examine stored data      */
 }
    d := a.D; v:= a.V; XX := a.X;
//  if(d>=n)                                     /* if depth sufficient:     */
    if d >= n then
    begin
//  {if(v>=l|X&S&&v<=q|X&8)return v;             /* use if window compatible */
      if (v >= LL) or (XX and SS <> 0) and (v <= QQ) or (XX and 8 <> 0) then
      begin
        Result := v;
        Exit;
      end;
//   d=n-1;                                      /* or use as iter. start    */
    d := n -1;
//  }X&=~M;Y=a->Y;                               /*      with best-move hint */
    end;
    XX := XX and (not MM);
    YY := a.Y;
//  Y=d?Y:0;                                     /* don't try best at d=0    */
    if d = 0 then
      Y := 0;
// }else d=X=Y=0;                                /* start iter., no best yet */
  end else begin
    YY := 0;
    XX := 0;
    d  := 0;
  end;
 
// N++;                                          /* node count (for timing)  */
  Inc(NN);
// W(d++<n|z==8&N<1e7&d<98)                      /* iterative deepening loop */
  while W2 do
  begin
// {x=B=X;                                       /* start scan at prev. best */
    BB := XX;
    x := BB;
//  Y|=8&Y>>4;                                   /* request try noncastl. 1st*/
    YY := YY or 8 and YY shr 4;
//  m=d>1?-I:e;                                  /* unconsidered:static eval */
    if d > 1 then m := -II else m := e;
//  do{u=b[x];                                   /* scan board looking for   */
    repeat
       u := b[x];
//   if(u&k)                                     /*  own piece (inefficient!)*/
       if (u and k) <> 0 then
       begin
//   {r=p=u&7;                                   /* p = piece type (set r>0) */
         p := u and 7;
         r := p;
//    j=o[p+16];                                 /* first step vector f.piece*/
         j := o[p + 16];
//    W(r=p>2&r<0?-r:-o[++j])                    /* loop over directions o[] */
         while W3 do
         begin
//    {A:                                        /* resume normal after best */
  A_:
//     y=x;F=G=S;                                /* (x,y)=move, (F,G)=castl.R*/
           y := y;
           GG := SS;
           FF := GG;
//     do{H=y+=r;                                /* y traverses ray          */
           repeat
             y := y + r;
             HH := y;
//      if(Y&8)H=y=Y&~M;                         /* sneak in prev. best move */
             if (YY and 8) <> 0 then
             begin
               y := YY and (not MM);
               H := y;
             end;
//      if(y&M)break;                            /* board edge hit           */
             if (y and MM) then
               Break;
//      if(p<3&y==E)H=y^16;                      /* shift capt.sqr. H if e.p.*/
            if (p < 3) and (y == EE) then
              HH := y xor 16;
//      t=b[H];if(t&k|p<3&!(r&7)!=!t)break;      /* capt. own, bad pawn mode */
            t := b[JJ];
            if (t and k or p) < (3 and (not (r and 7)) <>
      i=99*w[t&7];                             /* value of capt. piece t   */
      if(i<0||E-S&&b[E]&&y-E<2&E-y<2)m=I;      /* K capt. or bad castling  */
      if(m>=l)goto C;                          /* abort on fail high       */
 
      if(h=d-(y!=z))                           /* remaining depth(-recapt.)*/
      {v=p<6?b[x+8]-b[y+8]:0;                  /* center positional pts.   */
       b[G]=b[H]=b[x]=0;b[y]=u&31;             /* do move, strip virgin-bit*/
       if(!(G&M)){b[F]=k+6;v+=30;}             /* castling: put R & score  */
       if(p<3)                                 /* pawns:                   */
       {v-=9*(((x-2)&M||b[x-2]!=u)+            /* structure, undefended    */
              ((x+2)&M||b[x+2]!=u)-1);         /*        squares plus bias */
        if(y+r+1&S){b[y]|=7;i+=C;}             /* promote p to Q, add score*/
       }
       v=-D(24-k,-l-(l>e),m>q?-m:-q,-e-v-i,    /* recursive eval. of reply */
            J+J(0),Z+J(8)+G-S,F,y,h);          /* J,Z: hash keys           */
       v-=v>e;                                 /* delayed-gain penalty     */
       if(z==9)                                /* called as move-legality  */
       {if(v!=-I&x==K&y==L)                    /*   checker: if move found */
        {Q=-e-i;O=F;return l;}                 /*   & not in check, signal */
        v=m;                                   /* (prevent fail-lows on    */
       }                                       /*   K-capt. replies)       */
       b[G]=k+38;b[F]=b[y]=0;b[x]=u;b[H]=t;    /* undo move,G can be dummy */
       if(Y&8){m=v;Y&=~8;goto A;}              /* best=1st done,redo normal*/
       if(v>m){m=v;X=x;Y=y|S&G;}               /* update max, mark with S  */
      }                                        /*          if non castling */
      t+=p<5;                                  /* fake capt. for nonsliding*/
      if(p<3&6*k+(y&V)==S                      /* pawn on 3rd/6th, or      */
          ||(u&~24)==36&j==7&&                 /* virgin K moving sideways,*/
          G&M&&b[G=(x|7)-(r>>1&7)]&32          /* 1st, virgin R in corner G*/
          &&!(b[G^1]|b[G^2])                   /* 2 empty sqrs. next to R  */
      ){F=y;t--;}                              /* unfake capt., enable e.p.*/
     }W(!t);                                   /* if not capt. continue ray*/
  }}}W((x=x+9&~M)-B);                          /* next sqr. of board, wrap */
C:if(m>I/4|m<-I/4)d=99;                        /* mate is indep. of depth  */
  m=m+I?m:-D(24-k,-I,I,0,J,Z,S,S,1)/2;         /* best loses K: (stale)mate*/
  if(!a->K|(a->X&M)!=M|a->D<=d)                /* if new/better type/depth:*/
  {a->K=Z;a->V=m;a->D=d;A->K=0;                /* store in hash,dummy stays*/
   a->X=X|8*(m>q)|S*(m<l);a->Y=Y;              /* empty, type (limit/exact)*/
  }                                            /*    encoded in X S,8 bits */
/*if(z==8)printf("%2d ply, %9d searched, %6d by (%2x,%2x)\n",d-1,N,m,X,Y&0x77);*/
 }
 if(z&8){K=X;L=Y&~M;}
 return m;
}
 
main()
{
 int j,k=8,*p,c[9];
 
 F(i,0,8)
 {b[i]=(b[i+V]=o[i+24]+40)+8;b[i+16]=18;b[i+96]=9;   /* initial board setup*/
  F(j,0,8)b[16*j+i+8]=(i-4)*(i-4)+(j-3.5)*(j-3.5);   /* center-pts table   */
 }                                                   /*(in unused half b[])*/
 F(i,M,1035)T[i]=random()>>9;
 
 W(1)                                                /* play loop          */
 {F(i,0,121)printf(" %c",i&8&&(i+=7)?10:n[b[i]&15]); /* print board        */
  p=c;W((*p++=getchar())>10);                        /* read input line    */
  N=0;
  if(*c-10){K=c[0]-16*c[1]+C;L=c[2]-16*c[3]+C;}else  /* parse entered move */
   D(k,-I,I,Q,1,1,O,8,0);                            /* or think up one    */
  F(i,0,U)A[i].K=0;                                  /* clear hash table   */
  if(D(k,-I,I,Q,1,1,O,9,2)==I)k^=24;                 /* check legality & do*/
 }
}

[Roland Chastain]

Merci beaucoup pour ton travail, Paul. C'est très instructif.

Cette ligne-ci (41) est à corriger, non ?

Code :

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

  II = 8e4;

[Roland Chastain]

Non, ça veut dire 80000.

Je n'avais jamais vu cette écriture.

[Paul TOTH]

Non, ça veut dire 80000.

Je n'avais jamais vu cette écriture.

C'est la notation scientifique en puissances de 10.

[Roland Chastain]

c'est la notation scientifique en puissances de 10

Je ne savais pas qu'on pouvait l'utiliser dans le code.

Quand je serai grand, j'écrirai des choses comme ça :

Code :

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

Result := (d < n or z) = (8 and NN < 1e7) and (d < 98);

[Paul TOTH]

Je ne savais pas qu'on pouvait l'utiliser dans le code.

Quand je serai grand, j'écrirai des choses comme ça :

Code :

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

Result := (d < n or z) = (8 and NN < 1e7) and (d < 98);

Sauf que c'est sans doute

Code :

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

Result := (d < n) or (z = 8) and (NN < 1e7) and (d < 98);

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 disais plus haut, il faut vérifier l'ordre des opérateurs.