Voir le rapport

Rapport projet programmation
logique
« Jeu Teeko »
Réalisé par :
Encadré par :
LEROUX Joseph
DKHISSI Salah
JOUNDI Sahar
Année Universitaire 2015-2016
1|Page
Sommaire
I.
Présentation des règles du jeu ............................................................................................................................4
II.
Algorithmes pour l’intelligence artificielle ....................................................................................................6
1.
Choix de l’algorithme ....................................................................................................................................6
2.
Algorithme minimax ......................................................................................................................................6
3.
Elagage alpha-bêta .........................................................................................................................................7
III.
Principaux prédicats ..........................................................................................................................................8
1.
Mouvement d’une pièce ...............................................................................................................................8
2.
Changer de joueur ..........................................................................................................................................8
3.
Fonction d’évaluation ...................................................................................................................................8
4.
Boundedbest/6 ................................................................................................................................................9
5.
Alpha-bêta..........................................................................................................................................................9
6.
Fin de jeu ............................................................................................................................................................9
IV.
V.
Interface Graphique ......................................................................................................................................... 10
1.
Généralités ...................................................................................................................................................... 10
2.
Choix de notre interface ............................................................................................................................ 10
3.
Explication du code ..................................................................................................................................... 10
Difficultés rencontrées ........................................................................................................................................ 12
1.
Interface graphique : .................................................................................................................................. 12
2.
Débogage :....................................................................................................................................................... 12
VI.
Amélioration possibles : ................................................................................................................................ 13
VII.
Bibliographie ...................................................................................................................................................... 15
VIII.
Table de figures ................................................................................................................................................. 15
2|Page
Introduction
Dans le cadre du module de Programmation logique nous sommes amenés à
réaliser un jeu à deux joueurs où des notions vues en cours telles que les algorithmes
Minimax et α β pourront être exploités et approfondis.
Nous avons pour objectif de concevoir les deux partie du jeu « Teeko » : homme
vs machine et homme vs homme avec une interface graphique qui facilite l’utilisation du
jeu.
3|Page
I.
Présentation des règles du jeu
TEEKO est un jeu de stratégie combinatoire qui se joue à deux jours sur un plateau de
5*5 cases tel que le plateau ci-dessous :
Figure 1: Plateau de jeu "TEEKO"
Chaque joueur dispose de 4 pions de couleur rouge ou noire. L’objectif de chaque joueur
est de former l’une des configurations suivantes :
-
Une ligne verticale de 4 pions
Figure 2:Position gagnante1
4|Page
-
Une ligne horizontale de 4 pions
Figure 3: Position gagnante2
-
Une diagonale de 4 pions
Figure 4: Position gagnante3
-
Un carré de 4 pions
Figure 5: Position gagnante4
Le jeu se déroule en 2 phases :
Phase 1 :
Au départ le plateau est vide. Chaque joueur, à tour de rôle, va placer l’un de ses
pions dans l’une des cases vides. La première phase dure donc au maximum 8 tours,
chaque joueur plaçant successivement chacun de ses 4 pions. La phase 1 peut être plus
courte si l’un des joueurs forme l’une des configurations gagnantes décrites
précédemment. Une fois que les deux joueurs ont placés leurs pions et si aucun des deux
n’a gagné, on passe à la phase 2.
5|Page
Phase 2 :
Une fois le placement de tous les pions est effectué, on passe à la deuxième phase.
Les joueurs déplace un par un leurs pion sur les, c.à.d. verticalement, horizontalement
ou en diagonale. Et ainsi de suite jusqu’à ce que l’un des 2 joueurs remporte la partie en
formant l’une des figure gagnante ci-dessus.
II.
Algorithmes pour l’intelligence artificielle
1.
Choix de l’algorithme
Nous avons tout d’abord pensé à utiliser l’algorithme minimax pour implémenter
le fonctionnement de notre intelligence artificielle. Cette IA aura ensuite pour rôle de
permettre à l’ordinateur de jouer au jeu Teeko. L’ordinateur va essayer tous les coups
possibles et juger celui qui sera meilleur.
L’algorithme étant vu en cours pour le tictactoe, il nous semblait intéressant de
l’utiliser. Néanmoins, l’utilisation de cet algorithme étant moins avantageuse que
l’élagage alpha beta, nous avons opté pour ce dernier puisqu’il ne nécessite pas de
parcourir entièrement l’arbre de recherche, ce qui présente un gain de temps.
2.
Algorithme minimax
L’utilisation de l’algorithme minimax nécessite certains prérequis :




Un jeu alterné : chaque agent joue à tour de rôle. Dans notre cas 2 joueurs.
Un environnement déterministe Exemple, si un joueur de Teekochoisit de jouer la
première colonne, il est possible de déterminer la totalité du plateau de jeu après
cette action.
Un environnement à information parfaite : Le plateau du jeu du Teeko est visible
par tous, alors que dans le poker, le jeu des adversaires ne l’est pas.
Un jeu à somme nulle : la somme des gains de tous les joueurs s’annule. Exemple, si
on définit le gain d’une partie de Teeko comme 1 si on gagne, 0 si ex æquo et -1 si on
perd, alors dans tous les cas, à la fin de la partie, la somme des gains est nulle.
Autrement dit, une situation favorable pour un joueur est obligatoirement
défavorable pour ses adversaires
L’algorithme minimax consiste à générer un arbre de jeu, qui à partir de l’état
initial, va créer une branche pour chaque coup possible du joueur actuel, ce qui va
changer l’état du jeu, puis pour chacun de ces nouveaux états, va créer une branche pour
chaque coup possible de l’adversaire et ainsi de suite...
Il consiste ainsi à passer en revue pour un nombre limité de coups et à donner
une valeur à un état du jeu à la fin de n coups. Le meilleur choix est alors celui qui
minimise les pertes du joueur tout en supposant que l’adversaire cherche au contraire à
les maximiser (puisque le jeu est à somme nulle).
6|Page
Un exemple d’arbre généré par l’algorithme minimax tiré de Wikipédia est présenté cidessous.
Figure 6 : Arbre de recherche du minimax
3.
Elagage alpha-bêta
L’algorithme minimax est l’algorithme qui colle parfaitement à notre problème,
mais il présente un inconvénient majeur : il produit trop de possibilités.
Prenons par exemple le cas du troisième tour. Chacun des joueurs a posé un pion. Le
joueur suivant aura donc 23 possibilités pour poser son pion suivant, et le joueur
d’après 22 possibilités pour chacune des 23 possibilités, ce qui nous fait déjà 22*23 =
506 possibilités. Si l’on continue un tour de plus, on aura 506*21 = 10626 possibilités, ce
qui devient rapidement énorme.
C’est pourquoi nous avons décidé d’implémenter l´élagage alpha-bêta. Il permet
en effet de réduire le nombre de possibilités, et donc le nombre d’appels à la fonction
d’évaluation en supprimant les branches dont on est sûr qu’elles seront moins bonnes
que les branches déjà évaluées.
Voici un exemple d’élagage tiré sur Wikipédia
Figure 7 : Elagage Alpha-Beta
7|Page
III. Principaux prédicats
1.
Mouvement d’une pièce
Le mouvement d’une pièce est représenté par les prédicats suivants:
move([ ?Player1 , ?State, ?Board] , [?Player2, ?State, ?NextBoard])
Le prédicat est utilisé en mode homme vs machinechange de joueur avec nextPlayer/2 et
l’état change si le prochain coup permet d’atteindre une position finale. Le plateau de
jeu change en circonstance grâce au prédicat à l’aide de move_aux/3.
humanMove([?Player1, ?play, ?Board], [?Player2, ?State, ?NextBoard], ?Pos)
Ce prédicat est similaire au précèdent avec ?Pos un itérateur, mais il est utilisé dans le
mode homme vs homme.
2.
Changer de joueur
C’est le prédicat nextPlayer( ?Player1, ?Player2)qui permet à un état donné de changer
de joueur.
3.
Fonction d’évaluation
Le prédicat utility/2 calcule le nombre de points correspondants au placement des pions
en cours. Il peut être compris entre -200 et 200, la borne supérieure étant la victoire du
joueur dont la couleur est passée en paramètre et la borne inférieure celle de
l’adversaire. Lorsque ce nombre est positif, la position actuelle des pièces favorise le
joueur concerné. Dans le cas contraire, elle favorise le joueur adverse.
Ce nombre est calculé en fonction de plusieurs critères, le principal étant la victoire ou
non de l’un des joueurs. Si ce cas n’est pas présent, le programme tente de détecter
d’autres éléments, en fonction de la phase de jeu en cours.
Le centre du plateau contient les emplacements avec le plus de valeurs puisqu’ils
accordent plus de possibilités pour arriver à un état gagnant.
8|Page
Figure 8 : Notre Plateau avec les
cases centrales prises
4.
Boundedbest/6
La détermination du meilleur choix local et l’évaluation est effectuée par le prédicat
suivant
boundedbest(PosList,Alpha,Beta,Suc,Val, Prof)
Le paramètre Poslist est une liste de plateaux successeurs calculés à partir de la
position actuelle par le prédicat moves/2.
Le prédicat boundedbest/6 va déterminer le meilleur successeur à partir de cette
liste en prenant en compte les paramètres :



Val pour la valeur d’une configuration
Alpha et Bêta pour l’élagage
Prof pour la profondeur de l’arbre de recherche
5.
Alpha-bêta
L’élagage alpha-bêta est effectué par le prédicat suivant :
alphabeta( ?Pos, ?Alpha, ?Beta, ?Suc, ?Val, ?Prof)




Le paramètre Pos est la position du joueur (liste de 25 éléments)
Les paramètres Alpha, Beta et Val sont des entiers compris entre -200 et 200
Le paramètre Suc est le meilleur plateau Successeur à partir de Pos déterminé
par le prédicat boundedbest/6
Le paramètre Prof est la profondeur de recherche de l’arbre. A partir d’une
profondeur 4, l’IA prend plus de temps pour déterminer un meilleur coup.
6.
Fin de jeu
Le jeu se termine soit par une victoire, soit par une défaite, soit encore par un nul.
a)
Victoire et défaite : winPos(?Player, ?Board)
Le prédicat winPos( ?P, ?B) indique toutes les configurations gagnantes pour accéder à la
victoire. Nous nous sommes inspirés du même prédicat que celui présent dans le jeu
tictactoe avec plus de possibilités gagnantes (44 combinaisons).
Le joueur 1 gagne si winPos( Player1, Board)renvoie true, et le joueur 2 perd dans ce cas.
b)
Egalité :drawPos(?Player, ?Board)
Ce prédicat permet de déclarer le match nul lorsque le plateau est plein et qu’aucun des
deux joueurs n’a gagné.
9|Page
IV. Interface Graphique
1.
Généralités
Nous avons utilisé la bibliothèque XPCE qui fournit une interface graphique à
SWI-PROLOG. Aucune installation spéciale n’est requise pour utiliser la dite
bibliothèque, elle est automatiquement chargée dès qu’un de ses prédicats est appelé.
Afin d’éviter toute erreurs nous l’avons appelé explicitement par l’instruction :
- : use_module(library(pce)).
2.
Choix de notre interface
o Nous avons un menu qui propose à l’utilisateur de :
- Jouer à deux
- Jouer contre l’ordinateur
- Quitter le jeu
o Le plateau vide est un ensemble d’image de pions vide concaténés
o Nous avons considéré chaque case dans le plateau de jeu comme un bouton sur
lequel l’utilisateur doit cliquer pour que le pion apparaisse.
o Le plateau se recharge à chaque tour pour remplacer les pions vide avec des
pions rouge ou noir
3.
Explication du code
o Le prédicat debut/0avec lequel l’exécution de notre jeu commence. On crée notre
menu dans ce prédicat
debut :- new(D, dialog('teeko')),
send(D, display, text('Bienvenue dans votre jeu teeko'), point(0, 0)),
send(D,append,button(hommevsmachine, message(@prolog, hvsm))),
send(D, append,button(hommevshomme, message(@prolog, hvsh))),
send(D, append,button(quit, message(D, destroy))),
…
send(D, open).
-
New crée un objet de type dialogue
Un bouton pour l’interface homme vs machine
Un bouton pour l’interface homme vs homme
Un bouton pour quitter le jeu ou on utilise le destroy pour détruire la partie
10 | P a g e
Figure 9: Notre Accueil
o Le prédicat récursif show. Le plus important prédicat de l’interface puisque c’est la
ou se crée le plateau de jeu
o
show3([H|T],N) :-
new(IV, image('vide.bmp')),new(BV,bitmap(IV)),
new(IN, image('noir.bmp')),new(BN,bitmap(IN)),
new(IR, image('rouge.bmp')),new(BR,bitmap(IR)),
(
H=0
-> new(D, button(imagevide, message(@mw,return, N))), send(D,
label(BV));
H=o
-> new(D, button(imagerouge, message(@mw,return, N))),
send(D, label(BR));
H=x
-> new(D, button(imagenoir, message(@mw,return, N))),
send(D, label(BN))
),
(
0 is mod(N,5)
->send(@mw,append,D,below);
send(@mw,append,D,right)
),
N1 is N+1,
show3(T,N1).
Les 3 premier NEW servent à charger les images correspondantes aux jetons rouge, vide
et noir. Le prédicat bitmap de la librairie XPCE sert à mettre une image dans un objet
graphique qui peut être affichée sur un dispositif.
Dans le “If then else” on attribue au jeton vide qui est associé au ‘0’ l’image du jeton vide
Respectivement au jeton rouge (o) et au jeton noir (x) les images rouge et noir.
11 | P a g e
Pour avoir un plateau de 5*5, on concatène les images jusqu’à ce que le nombre
d’images sur une ligne soit divisible par 5 pour retourner à la ligne.
V. Difficultés rencontrées
1.
Interface graphique :
Nous n’avons pas trouvé assez de documentation en ligne à fin de pouvoir faire
une interface graphique assez belle et intuitive.
2.
Débogage :
Comme nous avons des prédicats qui appellent d’autres qui eux même appel le
prédicat appelant comme dans le cas de alphabeta\6 qui appel boundbest\6 qui luimême appel alphabeta\6. Alors trouver les erreurs devient difficile.
3.
Intelligence artificielle
Nous avons implémenté l’algorithme alpha-bêta pour le fonctionnement de l’intelligence
artificielle. Le problème fut que, malgré le fonctionnement de l’algorithme, ce dernier ne
semble pas fonctionner comme il se doit : L’algorithme ne renvoie pas tout le temps le
meilleur coup évalué par notre prédicat d’évaluation utility/2.
Nous avons essayé de résoudre le problème de plusieurs manières en essayant de
debugger, d’utiliser d’autres prédicats de tri de liste1 mais en vain. Nous avons même
tenté de recourir à l’alternative minimax en profondeur mais celui-ci fonctionnait encore
moins bien.
Les coups de l’ordinateur sont linéaires et commencent vers le bas à cause, notamment,
du prédicat move_aux/3.
Nous avons remarqué que c’est généralement le dernier élément de la liste renvoyé par moves/2 qui est
renvoyé par alpha-bêta
1
12 | P a g e
Néanmoins, l’IA bloque toutes les combinaisons gagnantes sauf quand
l’adversaire a au moins deux possibilités de gagner.
Blocage
L’IA tente également de maximiser le nombre de possibilités gagnantes au cas où
l’adversaire en bloquerait une :
VI. Améliorations possibles :
-
Mettre en place les niveaux de difficultés pour l’intelligence artificielle
Gérer les scores des joueurs
Améliorer l’interface
Représenter le plateau par coordonnées (x,y) pour optimiser le temps de recherche
du meilleur coup
Mettre en place une heuristique plus intuitive qui sera défini dynamiquement
13 | P a g e
Conclusion
Durant la réalisation de ce projet, nous avons eu l'occasion d'appliquer les
connaissances acquises en cour de prolog, mais également de découvrir le travail
entourant la programmation logique lors de la création d'une intelligence artificielle.
En plus de s'appliquer au jeu Teeko, les connaissances utilisées, ainsi que le
programme créé, pourraient facilement s'adapter à d'autres jeux basés sur le même
principe, qui est celui du tour à tour. L'intelligence artificielle du jeu puissance4, par
exemple, ne serait pas très différente, puisqu'il ne s'agit que d'une adaptation de la
phase de placement du Teeko.
14 | P a g e
VII. Bibliographie
Cours et Tps
https://fr.wikipedia.org/wiki/ minimax et alpha-bêta
http://jeuxsoc.fr/jeu/teeko.0.0 règles du jeu et modèle
http://jfoutelet.developpez.com/articles/xpce/ interface graphique forum
http://www.swi-prolog.org/packages/xpce/
interface graphique notice d’utilisation
http://www.montefiore.ulg.ac.be/~lens/prolog/tutorials/tictactoe.pl
exemple
du
tictactoe
VIII. Table de figures
Figure 1 : Plateau de jeu "TEEKO"............................................................................................................. 4
Figure 2 : Position gagnante1 ..................................................................................................................... 4
Figure 3 : Position gagnante2 ..................................................................................................................... 5
Figure 4 : Position gagnante3 ..................................................................................................................... 5
Figure 5 : Position gagnate4 ........................................................................................................................ 5
Figure 6 : Arbre de recherche MinMax.................................................................................................... 7
Figure 7 : Arbre de recherche AlphaBeta ............................................................................................... 7
Figure 8 : Notre Plateau ................................................................................................................................ 8
Figure 9 : Notre Accueil .............................................................................................................................. 11
15 | P a g e