SIMNUM : Jeux dechecs

sujet propose par Nicolas Kielbasiewicz : nicolas.kielbasiewicz@ensta-paristech.fr

29 janvier 2014

Il sagit dans ce projet de realiser un jeu dechecs permettant `a u joueur humain daffronter
lordinateur. Ce dernier utilisera un algorithme de tyoe min-max pour jouer. Dans une premi`ere etape,
on developpera une version non graphique et dans une seonde etape si le temps le permet, on developpera
une interface graphique sappuyant sur les outils developpes dans la premi`ere phase. La realisation de ce
projet suppose un minimum de connaissances des echecs (au moins les r`egles). Il nest pas question, vu le
temps imparti, de faire jouer la machine comme un grand matre ! Dans ce qui suit ne sont enonces que
les principes generaux et quelques elements sur les classes `a utiliser. Bien evidemment, il vous appartient
de preciser et de completer ces classes, voire den ajouter de nouvelles si le besoin sen fait sentir.

Principe de lalgorithme du min-max

Cet algorithme lest pas specifique, il sapplique `a tout jeu `a deux joueurs au tour par tour. Un
tel jeu peut etre vu comme une succession de positions, resultats des coups alternes des joueurs. Nous
noterons Pih une position que doit jouer le joueur humain et Pic une position que doit jouer lordinateur.
A un instant donne de la partie, supposons que le joueur humain doit jouer `a partir de la position
h qui vont produire autant de positions P c
P0h . Il a en general un nombre fini de coups possibles C0,k
1,k
que lordinateur va devoir jouer et ainsi de suite. Ce qui nous donne un arbre de toutes les possibilites
devolution du jeu.
P0h
h
C1,1

P1,1c
c
C2,1
h
P2,1

c
C2,2
h
P2,2

h
C1,2

P1,2c

h
C1,3

P1,3c

h
C1,4

P1,4c

c
C2,3
h
P2,3

On definit maintenant une fonction valeur dune position V (P ). La valeur dune position gagnante
pour le joueur humain vaut , dune position perdante et dune position de match nul 0. La valeur
dune position autre sera calculee en fonction dheuristiques liees au jeu. Par exemple aux echecs, on
pourra prendre la difference des valeurs des pi`eces encore presentes sur lechiquier entre les 2 joueurs
`a laquelle on ajoute la difference du nombre de cases controlees par les 2 joueurs. On definit alors la
fonction MinMax dune position quelconque P de la facon suivante :

si P est une position terminale

V (P )
MinMax(P ) = max (MinMax(P1 ), . . . , MinMax(Pk )) si P est une position du joueur

min (MinMax(P1 ), . . . , MinMax(Pk )) si P est une position de lopposant

P1 , . . . , Pk designant toutes les positions obtenues apr`es 1 coup. Lalgorithme du min-max consiste
`a calculer la fonctionMinMax de toutes les positions issues du premier coup du joueur (humain dans
lexemple) et `a jouer le coup qui donne une position maximale.

-4
max

10

-4

min

min

-4

15

Cet algorithme part du principe que le joueur opposant jouera le coup presentant la plus petite
valeur et conduit `
a des strategies defensives (pas de prise de risque).

1.1

La variante

La variante consiste `
a stopper lexploration dune branche d`es lors qu`a un niveau
correspondant `a une phase de minimisation, on trouve une valeur inferieure `a une valeur min-max
du niveau precedent. En effet, on peut abandonner lexploration car on est s
ur que le joueur cherchant `
a
maximiser sa position ne jouera pas un coup produisant une valeur inferieure `a celle quil a dej`a trouvee.
De meme, on stoppera lexploration dune branche si en phase de maximisation, on trouve une valeur
superieure `a une valeur min-max du niveau precedent. Dans lexemple suivant :
-4
max

10

-4

<-6

min

min

-4

-6

15

lexploration de la deuxi`eme branche est stoppee car -6 < -4.

1.2

Impl
ementation de lalgorithme du min-max

Pour ecrire dun algorithme du min-max, il suffit de disposer dune classe Position qui doit au
moins fournir :
une fonction qui renvoie la valeur dune position
un pointeur sur la position sur
un pointeur sur la premi`ere position fille
un indicateur sur le joueur qui doit jouer cette position
Comme il peut y avoir enormement de positions `a explorer, il est parfois preferable de generer les
positions suivantes au fur et `
a mesure plut
ot que de fabriquer larbre complet avant de lancer lalgorithme
du min-max. Bien evidemment, une fois lexploration dune branche terminee, on detruit les positions.
Cest pourquoi il sera judicieux de prevoir, entre autres, les fonctionnalites suivantes :
2

 generateur de toutes les positions suivantes `a une profondeur donnee

destructeur de toutes les positions filles dune position (par recursivite, toutes les positions
seront detruites)
On pourra valider lagorithme sur un jeu tr`es simple, par exemple le tic-tac-toe (premier `a aligner
3 pions dans un carre 3x3) :

Cest un cas o`
u on peut developper larbre jusqu`a la fin de la partie ( !9=362880). Normalement,
lordinateur ne peut pas perdre.

2
2.1

Application aux
echecs :
el
ements de conception
D
efinition des pi`
eces et d
eplacements
On commencera par definir une classe TypePiece ayant les attributs suivants :
un type valant roi, reine, four, cavalier, tour ou pion
un deplacement relatif
une valeur : 0 pour le roi, une valeur v arbitraire pour le pion, 9v pour la reine, 5v pour la tour,
et 3v pour le fou et le cavalier.
On definira ensuite une classe Piece ayant les attributs suivants :
le type de la pi`ece
la couleur de la pi`ece (noir ou blanc)
la position de la pi`ece sur lechiquier

2.2

D
efinition de l
echiquier

On definira une classe Echiquier qui sera un tableau 8x8 de pointeurs de pi`eces. Si une case de
lechiquier nest pas occupee, la case correspondante du tableau sera un pointeur nul, sinon, ce sera le
pointeur sur la pi`ece occupant la case. Cela permet davoir en permanence une  image  de lechiquier.
On pourra adjoindre `
a cette classe une fonction print permettant de suivre levolution de la partie `
a
lecran ou dans un fichier texte.
Tn

Fn Dn Rn Fn

Tn

Pn Pn Pn Pn Pn Pn Pn Pn
Cn

Cn

Pb
Pb
Pb Pb Pb

Pb Pb Pb

Tb Cb Fb Db Rb Fb Cb Tb

2.3

D
efinition dun coup

Afin de suivre le deroulement de la partie, on definira une classe Coup, ayant les attributs suivants :
la couleur
la pi`ece jouee
lancienne position
la nouvelle position
sil y a prise de pi`ece
si cest un coup special (roque)
Pour la position dune pi`ece, on utilisera un couple (i, j). Il pourra etre utile davoir une fonction
generant le codage standard dun coup (FouC1-D2, Dame D1-D7+,O-O,OO), voir sur internet.

2.4

D
efinition dune position

Il sagit dun etat temporaire de lechiquier. Comme il serait trop volumineux de stocker letat
de lechiquier apr`es chaque coup, on va definir une classe Position decrivant une position relative par
rapport `a un echiquier de reference (le dernier etat connu de lechiquier) en indiquant seulement la liste
des coups permettant de passer de lechiquier de reference `a la position temporaire. Lorsque lon aura
besoin davoir tout lechiquier, on en gen`erera un temporaire. Bien evidemment, cette classe sera munie
de tous les attributs et fonctionnalites necessaire `a lalgorithme du min-max.

2.5

G
en
eration de toutes les positions

A partir dune position donnee, on aura besoin de generer lensemble des coups suivants possibles
et les positions en decoulant. Cest une operation co
uteuse car il faut envisager le deplacement de toutes
les pi`eces et verifier que le deplacement dune pi`ece ne met pas le roi en position dechec.

2.6

Valeur dune position

La valeur dune position sera pour une position gagnante et pour une position perdante
(echec et mat), 0 pour une partie nulle (pat) et sera donnee pour une autre position par :
(val piece(j1 ) val piece(j2 )) + (cont(j1 ) cont(j2 ))
o`
u val piece(j) represente la valeur des pi`eces encore presentes du joueur j et cont(j) le nombre de cases
controlees par le joueur j.
La premi`ere partie correspond `
a un crit`ere quantitatif essentiel aux echecs et la second `a un crit`ere
qualitatif sur loccupation de lechiquier. Les param`etres et pond`erent limportance dun crit`ere par
rapport `a lautre et cette formule permet `a lordinateur de jouer un peu mieux quun debutant. Une
grande partie de la qualite dun jeu dechecs par ordinateur depend du choix de ces crit`eres.

2.7

D
efinition dune partie
On ecrira un programme permettant de gerer le deroulement dune partie :
initialisation de lechiquier
sequence de 2 coups : precalcul des coups possibles pour le joueur 1 (humain), coup joue par le
joueur 1, determination du meilleur coup du joueur 2 (ordinateur) `a laide du min-max, coup
du joueur 2
memorisation de lhistorique des coups joues et fonction dannulation dun coup
affichage du deroulement de la partie

Validation

On validera chacune des fonctionnalites du programme. On portera une attention particuli`ere au

co
ut calcul. En effet, il y a en moyenne 30 `a 40 coups possibles en debut et milieu de partie. Si on veut
que lordinateur joue correctement, il faut explorer au moins 4 coups (2 par joueurs), ce qui donne de
lordre de 1 millions de positions.

Interface graphique

Sil reste du temps, on pourra essayer de developper une interface graphique avec un outil comme
kylix en reutilisant ce qui a ete developpe precedemment.