SlideShare une entreprise Scribd logo
1  sur  14
Télécharger pour lire hors ligne
Jeu de Siam
                          IA02 – Projet 2012
    Création d’un système de jeu complet incluant une intelligence
                             artificielle.




                                       ELSA FRISCIRA
                                       MARC MULLER


Les éléphants et les rhinocéros s'affrontent dans une lutte sans merci. Les animaux se déplacent
sur le plateau et poussent des montagnes selon des règles de rapport de force bien précises. Le
               but est d'être le premier joueur qui sort une montagne du plateau.
Jeu de Siam
                                                                                Introduction


INTRODUCTION
Le projet de l’uv IA02 pour le semestre de printemps 2012 consiste à reproduire au moyen du
langage Prolog un logiciel permettant de jouer au jeu du Siam. Ce jeu devra permettre de
s’affronter entres humains ou bien de défier l’intelligence artificielle qui est à développer avec le
jeu.

Le jeu de Siam est un jeu où deux joueurs tentent de pousser des montagnes hors d’un plateau
de taille 5x5. Les pions peuvent se pousser entre eux et tenter de se bloquer. Malgré un plateau
de taille réduite, les possibilités de coup sont légions car chaque pion dispose également d’une
orientation sur sa case.

Nous allons présenter l’organisation de notre programme, décrire le fonctionnement des
prédicats principaux. Nous poursuivrons en présentant l’intelligence artificielle incluse et les
choix d’heuristiques faits. Enfin, nous présenterons les difficultés rencontrées au cours de ce
projet.


SOMMAIRE
Introduction ........................................................................................................................................................................ 2
Sommaire ............................................................................................................................................................................. 2
Note importante ................................................................................................................................................................ 3
I. Organisation du programme .................................................................................................................................... 4
II. Fichier BASE................................................................................................................................................................... 4
    A. Contenu ................................................................................................................................................................. 4
    B. Explications ......................................................................................................................................................... 4
    C. Structures de données..................................................................................................................................... 6
III. Fichier Mécanismes ................................................................................................................................................... 7
    A. Contenu ................................................................................................................................................................. 7
    B. Explications ......................................................................................................................................................... 7
    C. Structures de données..................................................................................................................................... 8
IV. Fichier IA ........................................................................................................................................................................ 9
    A. Contenu ................................................................................................................................................................. 9
    B. Explications ......................................................................................................................................................... 9
V. Fichier Notation .......................................................................................................................................................... 11
    A. Contenu ............................................................................................................................................................... 11
    B. Explications ....................................................................................................................................................... 11
    C. Conclusion sur l’IA .......................................................................................................................................... 13
Conclusion .......................................................................................................................................................................... 14




Friscira Elsa – Muller Marc                                                                                                                                          Page| 2
Jeu de Siam
                                        Note importante


NOTE IMPORTANTE
Nous commençons ce rapport par une note importante : nous nous sommes aperçus très peu de
temps avant le rendu du projet qu’une règle manquait à notre jeu. Il s’agit du fait qu’un pion
puisse rentrer sur le plateau en poussant un pion. Cette règle n’a pas été implémentée suite à
une incompréhension des règles du jeu (nous avions compris l’inverse !). Cependant, nous avons
réalisé notre erreur tard et avons décidé de ne pas la corriger pour deux raisons :

   -   ajouter si tard une règle dans le jeu serait le meilleur moyen de ne pas pouvoir la tester
       entièrement et cela pourrait donc induire des instabilités ou des erreurs dans le jeu
   -   l’intelligence artificielle a été développée sans connaître cette règle, et il serait long de
       lui en faire part tout en optimisant la pondération des heuristiques décrites dans la
       partie V. Le jeu contre l’IA serait faussé.

Nous nous excusons donc de ce manque et souhaitons malgré cela un bon jeu au testeur de notre
programme.




Friscira Elsa – Muller Marc                                                              Page| 3
Jeu de Siam
                                   I. Organisation du programme


I. ORGANISATION DU PROGRAMME
Notre programme Prolog est décomposé en quatre fichiers sources, contenant chacun une
section différente des mécanismes du jeu.

Pour lancer une partie du jeu, il faut tout d’abord charger chacun des quatre fichiers. Une fois
cette opération effectuée, il faut appeler le prédicat lancer_jeu/0 qui va alors présenter un menu
de jeu permettant de tester les différents types de parties !

| ?- lancer_jeu.
----- ----- -----
Choisissez le type de partie :
 - 1 : Humain contre humain
 - 2 : Humain contre IA
 - 3 : IA contre IA
 - 4 : Humain contre IA (version avec recherche de profondeur 2)
 - 5 : IA contre IA (version avec recherche de profondeur 2)
 - 6 : Humain contre IA (version avec recherche de profondeur 3)
 - 7 : IA contre IA (version avec recherche de profondeur 3)
 - 8 : Quitter


II. FICHIER BASE

A. Contenu
Le fichier s’intitule en réalité « ia02_friscira_muller_BASE.pl ». Dans ce premier fichier, on
retrouve les prédicats de base du jeu. Il s’agit principalement de :

    -   Le menu de lancement de partie
    -   Les prédicats de chargement et de sauvegarde du plateau de jeu
    -   La boucle de jeu
    -   Les prédicats d’affichage

B. Explications

1. La boucle de jeu
Le prédicat constituant la boucle de jeu est le prédicat jouer/0.

Ce prédicat commence par charger le plateau courant grâce au prédicat dynamique plateau/1 et
affiche ce plateau au joueur afin qu’il puisse étudier la situation.

Suite à cela, le prédicat utilise repeat/0 pour créer une boucle qui va permettre au joueur de saisir
un coup, jusqu’à ce que celui-ci soit valide. Dans cette boucle, nous demandons au joueur
d’entrer son coup sous la forme [Origine, Destination, Orientation], lisons ce coup et vérifions s’il
est possible grâce à coup_possible/3. Tant que le coup n’est pas possible, le prédicat renvoi faux
et la boucle recommence.

Si le coup est possible, on avance dans le prédicat jouer et on applique le coup du joueur.
Ensuite, on vérifie si le plateau résultant est vainqueur. Si tel est le cas, un message spécial
s’affiche, et la boucle de jeu s’interrompt car +victoire renvoi faux. Le joueur se retrouve alors

Friscira Elsa – Muller Marc                                                               Page| 4
Jeu de Siam
                                         II. Fichier BASE


sur le menu général du jeu, prêt à lancer une revanche ! Dans le cas contraire, si +victoire
renvoi vrai, c'est-à-dire que personne n’a gagné, alors on trouve qui est le prochain jouer grâce à
autre_joueur/2 et on sauvegarde le plateau grâce à set_plateu/1. Enfin, on « cut » pour s’assurer
que l’itération suivante de boucle ne revienne pas en arrière et on rappelle le prédicat jouer/0.

Résumé :
   - Chargement et affichage du plateau
   - Lecture d’un coup possible
   - Application du coup
   - Vérification de fin de partie
   - Changement de joueur, sauvegarde du plateau

Il existe deux autres versions de la boucle de jeu. La seconde version, nommée jouer_hu_ia/1 est
une version à deux clauses qui permet de jouer une partie humain contre IA. L’une des clauses
permet de faire jouer l’humain, celle-ci est strictement identique à jouer/0. L’autre clause permet
à l’IA de jouer, voici son fonctionnement :

Le début du tour se déroule de la même façon, on charge le plateau et on l’affiche. Ensuite, l’IA
fait appel à trouver_coup/4 qui est un prédicat qui va chercher le meilleur coup à jouer en
cherchant jusqu’à une certaine profondeur de coup. Une fois ce coup trouvé, la boucle de jeu
fonctionne similairement à celle du jeu humain.

La troisième version de la boucle de jeu est la version jouer_ia_ia/1 qui permet de faire jouer
l’ordinateur contre lui-même. Cette version ne contient qu’une seule clause strictement
identique à la clause du jeu IA du prédicat jouer_hu_ia/1 décrit ci-dessus.

Pour plus de détails, consulter le code documenté du fichier BASE.

2. L’affichage du plateau
Quelques mots sur l’affichage du plateau. Celui-ci est possible via l’appel d’afficher_plateau/1. Ce
prédicat en rappelle tout de suite un autre, qui est afficher_plateau/2 en lui communiquant la case
à partir de laquelle commencer l’affichage (le coin supérieur gauche). Le prédicat est constitué
de multiples clauses, qui permettent, au moyen de simples tests, de gérer les débuts et les fins de
lignes. En effet, si on affiche la première case d’une ligne, on trace le contour supérieur des
cases ; dans le même esprit, en fin de ligne, on trace la base de la ligne. Chaque appel réalise un
affichage et fait évoluer le numéro de case courante pour l’appel suivant.

Chaque case est affichée au moyen des prédicats afficher_case/2 et afficher_orientation/1.




Friscira Elsa – Muller Marc                                                              Page| 5
Jeu de Siam
                                            II. Fichier BASE




                                Figure 1 : Aperçu du plateau de jeu initial

3. Autres prédicats
Le prédicat lancer_jeu/0 est le prédicat racine, a appeler pour lancer une partie du jeu. Il s’agit
d’un simple menu qui initialise le plateau et donne la main à une boucle de jeu.

Le prédicat membre_alea/2 permet de choisir un élément au hasard dans une liste. Cela sera très
utile pour choisir entre deux coups à jouer semblables.

C. Structures de données
Terminons l’analyse de ce fichier en présentant les structures de données introduites.

1. Plateau de jeu
La structure du plateau de jeu est la suivante : [E,R,M,J], c'est-à-dire une liste contenant tout
d’abord deux listes de pions E et R ou chacun des 5 éléments est de la forme [Case, Orientation].
La liste M est une liste des trois montagnes du jeu, par exemple [32,33,34] initialement. J est une
variable contenant l’identifiant du joueur courant, par exemple ‘e’ pour éléphant ou ‘r’ pour
rhinocéros.

Exemple : [ [ [51,n],[23,s],[0,n],[12,o],[0,n] ],[ [11,e],[0,n],[35,o],[36,s],[0,n] ],[33,55,34],'e'] est
un plateau ou chaque camp dispose de trois pions sur le plateau et ou c’est au joueur e de jouer.

2. Coup
Un coup est une action effectuée par un joueur à un tour. Le coup est représenté par la liste
suivante : [Origine, Destination, Orientation] avec Origine la position du pion à déplacer,
Destination la position à laquelle envoyer ce pion et Orientation l’orientation d’arrivée du pion.

Exemple : [0, 11, 'n'] est le coup qui consiste à entrer un pion sur le plateau en 11 vers le Nord.




Friscira Elsa – Muller Marc                                                                  Page| 6
Jeu de Siam
                                      III. Fichier Mécanismes


III. FICHIER MECANISMES

A. Contenu
Le fichier s’intitule en réalité « ia02_friscira_muller_MECANISMES.pl ». Dans ce second fichier, on
retrouve les prédicats permettant de vérifier que les coups sont possibles et de les appliquer. Il
s’agit principalement de vérifier :

   -   L’orientation d’un coup
   -   La validité des déplacements
   -   L’état de la case d’arrivée
   -   Les entrées/sorties du plateau
   -   Les poussées et les rapports de force
   -   La fin de partie

B. Explications
Le prédicat central de ce nouveau fichier est le prédicat coup_possible/3. Son rôle est de s’assurer
que compte tenu d’un plateau donné, un coup est possible, et, si tel est le cas, de fournir les
mouvements résultants de ce coup (un coup simple ne provoquera qu’un mouvement, un coup
impliquant une poussée provoquera une liste de mouvement de translation). Cette liste de
mouvements fournie par coup_possible/3 sera nommée dans le projet « Impact ».

1. Coup possible, fonctionnement général
Le prédicat contient plusieurs clauses. Outre les trois premières qui sont des cas limites (comme
celui de quitter la partie ou de faire du surplace), intéressons-nous surtout aux deux dernières
clauses. On commence par vérifier le coup c'est-à-dire confirmer qu’il est bien orthogonal. On
s’assure en suite que le pion à déplacer appartient au joueur courant.

Si la case d’arrivée est libre, le prédicat est achevé et on renvoi un impact composé uniquement
du coup. En revanche, si la case de destination est occupée, on est redirigé sur la dernière clause
qui va, elle, engager une démarche pour vérifier que la poussée est possible. Après avoir vérifié
que le pion était déjà dans l’orientation souhaitée pour la poussée, on construit une liste de
poussée (cf. structures de données) et on vérifie que le rapport de force est en la faveur du
joueur, si oui, on renvoie un impact contenant tous les déplacements, sinon, coup_possible est
faux.

La première clause permet de quitter le jeu, la seconde d’empêcher de bouger de 0 vers 0, et la
troisième d’empêcher de rester sur place sans changer d’orientation.

2. Construction de liste de poussée
Il est nécessaire dans le cas d’une poussée de se construire une liste de poussée permettant
d’évaluer le rapport de force. Pour ce faire, on utilise le prédicat construire_liste_pions/4. Ce
prédicat utilise le plateau, l’origine de la poussée et son orientation pour construire notre
fameuse liste de poussée.

Le fonctionnement est le suivant : on étudie la case sur laquelle on est. En fonction de
l’orientation du pion qui s’y trouve, on ajoute à la liste de poussée un élément contenant un ‘+’,
ou ‘-‘, un espace ou un ‘M’. Puis, on calcule quelle est la case suivante dans la poussée et on

Friscira Elsa – Muller Marc                                                              Page| 7
Jeu de Siam
                                           III. Fichier Mécanismes


rappelle le prédicat. En fin de récursion, on a construit une liste contenant chaque pion sur son
chemin et sa contribution à la poussée (positive, négative, neutre ou montagne).

3. Evaluation du rapport de force
Quand on dispose d’une liste de poussée, on peut utiliser le prédicat calculer_force/3 pour nous
dire si la poussée est possible. Calculer force analyse la liste de poussée dans l’ordre, et entretien
deux compteurs : l’un de force et l’autre de poids. La force augmente et diminue pour chaque
pion ayant une contribution positive ou négative. Le poids augmente pour chaque montagne. A
chaque itération, la force doit surpasser le poids (>=) et en fin de calcul, la force doit être non
nulle.

4. Détection de fin de partie
Le prédicat victoire/4 permet de vérifier si le plateau est vainqueur. Le prédicat commence par
vérifier qu’une montagne a bien été sortie du plateau grâce à montagne_hors_limite/2. Ensuite, il
cherche qui a gagné en commençant par rechercher l’animal « poussant », c'est-à-dire le pion
ayant une contribution positive le plus proche de la montagne qui a été sortie. Enfin, il utilise
equipe/4 pour savoir à quel camp appartenait ce pion.

C. Structures de données
Quelques structures de données nouvelles ont été introduites.

1. Impact
Un impact est une liste de mouvements que l’on récupère grâce à coup_possible/3. Cette liste de
mouvements peut donc ensuite être appliquée à un plateau pour déplacer un par un chacun des
pions impactés par un coup. Chaque élément de la liste Impact contient l’origine du pion, sa
destination et son orientation d’arrivée.

Exemple : [ [11, 21, ‘n’], [21, 31, ’e’], [31, 41, ’e’]] est un Impact ou trois pions sont déplacés, à
priori par le premier d’entre eux, situé en 11.

2. Liste de poussée
Une liste de poussée est une structure permettant de décrire une ligne/colonne de poussée.
Chaque élément est caractérisé par la position du pion, sa contribution à la poussée et son
orientation. L’orientation n’a pas de réelle utilité dans les prédicats qui analysent une poussée,
MAIS permet de très facilement reconstruire un impact à partir d’une liste de poussée.

Exemple : [ [52, '+', 's'], [42, ' ', 'e'], [32, '+', 's'], [22, '-', 'n'], [52, 'M', 'M'] ] est une liste composée
de quatre pions et une montagne. Deux des pions contribuent positivement au mouvement (‘+’)
tandis qu’un autre gêne le mouvement (‘-‘) et qu’un autre est neutre (‘ ‘).




Friscira Elsa – Muller Marc                                                                           Page| 8
Jeu de Siam
                                            IV. Fichier IA


IV. FICHIER IA

A. Contenu
Le fichier s’intitule en réalité « ia02_friscira_muller_IA.pl ». Dans ce troisième fichier, on retrouve
les prédicats en charge de gérer l’intelligence artificielle du jeu, c'est-à-dire :

    -   Trouver les coups potentiels
    -   Filtrer les coups pour réduire la combinatoire
    -   Construire un arbre de recherche du meilleur coup

B. Explications
Nous allons présenter trois prédicats centraux.

1. Trouver les coups possibles
Le prédicat coups_possible/3 est un prédicat en mesure de trouver pour un plateau donné tous
les coups possibles avec leurs impacts respectifs et les plateaux générés par ces impacts.

Ce prédicat commence par lister tous les coups potentiels pour le joueur courant, c’est à dire en
proposant chaque déplacement orthogonal pour chaque pion et chaque orientation (et les cas de
rotation sur place), ainsi que les coups d’entrée ou de sortie de plateau. C’est le prédicat
coups_potentiels_joueur/2 qui créé cette longue liste.

Ensuite, coups_possible demande à réduire la quantité de ces coups. En effet, il existe
naturellement des doublons et des coups inutiles dont on peut se séparer pour atténuer la masse
de coups à envisager. C’est le prédicat reduire_coups_possibles/3 qui est en charge de ce travail, et
qui est expliqué dans la partie suivante (2.).

Une fois les coups filtrés pour ne conserver que ceux qui semblent intéressants, un second
filtrage permet de ne conserver que ceux qui sont effectivement possibles compte tenu de
plateau de jeu. Enfin, le prédicat retourne les coups, impacts et plateaux de jeux issus des coups
possibles.

2. Réduire le nombre de coups possibles
Pour réduire le nombre de coups possibles, le prédicat reduire_coups_possibles/3 utilise une
succession de sous-prédicats effectuant un traitement particulier.

La première tâche est de supprimer les doublons. En effet, si le joueur dispose de deux pions
hors du plateau, la liste des coups potentiels contient les mêmes mouvements pour chacun de
ces pions.

La seconde tâche consiste à nettoyer les coups qui sortent du plateau pour n’en conserver qu’un
par pion, puisqu’il est strictement identique qu’un pion en 55 sorte vers le haut ou vers la droite.

La troisième tâche consiste à supprimer les rotations inutiles. Le prédicat
supprimer_rotations_inutiles/3 analyse pour chaque rotation sur place si elle a du sens. Une telle
rotation n’a du sens que si le pion jouxte une case occupée. Ce choix est discutable car sur plus
d’un tour, une rotation sur place peut changer le déroulement d’une partie, mais nous
choisissons de filtrer ces coups pour réduire la combinatoire du jeu. Si je suis en case 11, s’il n’y

Friscira Elsa – Muller Marc                                                                Page| 9
Jeu de Siam
                                            IV. Fichier IA


a personne en 12 et en 21, alors je ne conserve pas les coups opérant une rotation sur moi-
même.

La quatrième étape consiste à filtrer les déplacements ayant la même destination mais une
orientation différente afin de ne conserver qu’une orientation d’arrivée si l’on juge que celle-ci
n’a pas d’importance pour le jeu. C'est-à-dire, que si je suis en 31, et que je vais en 32, alors si
toutes les cases autour de mon arrivée sont vides, je ne vais pas garder les quatre coups me
conduisant en 32, mais seulement celui qui conserve mon orientation actuelle. Encore une fois,
ce choix est discutable sur le long terme, mais c’est un sacrifice que nous consentons.

3. Trouver le meilleur coup à jouer
Le prédicat trouver_coup/4 fait le lien avec le dernier fichier, il permet de choisir le meilleur coup
à jouer en analysant les coups possibles futurs.

Fonctionnement général : pour le plateau passé en argument, on va chercher tous les coups
possibles et les plateaux résultants, et on va rappeler notre prédicat récursivement sur chacun
de ces plateaux. On communique au prédicat le niveau courant de recherche. On peut par
exemple appeler le prédicat avec un niveau de 3, et à chaque appel récursif, ce nombre est
décrémenté. On atteindra donc le bas de l’arbre en 3 appels.

Une fois le bas de l'arbre atteint (Niveau = 1), on note chaque plateau possible grâce au prédicat
noter_plateau/2 qui sera présenté en V et on retient le coup qui a généré le meilleur plateau. On
fait remonter sa note au niveau de récursion supérieur.

On utilise ensuite un fonctionnement « minimax ». A chaque niveau, le prédicat va soit retenir la
note maximale, soit la note minimale (avec le coup qui l'a générée et la note en question). En
alternant minimisation et maximisation, on simule le fait que quand A prévoit son coup, il tente
de maximiser ses coups et part du principe que B va maximiser lui aussi ses propres coups, ce
qui revient à minimiser le coup du point de vue de A. Avec un simple test de parité sur Niveau,
on sait donc si le prédicat doit faire le min ou le max des coups possibles à son niveau.

Une fois revenu au niveau le plus haut de la recherche, on retient donc le Coup de base qui a
conduit à la solution (feuille de l'arbre) la plus intéressante au travers d’une recherche à N
niveaux.




Friscira Elsa – Muller Marc                                                              P a g e | 10
Jeu de Siam
                                         V. Fichier Notation


V. FICHIER NOTATION

A. Contenu
Le fichier s’intitule en réalité « ia02_friscira_muller_NOTATION.pl ». Dans ce dernier fichier, on
retrouve les prédicats en mesure de noter un plateau en suivant plusieurs heuristiques :

    -   Le plateau conduit il à une fin de partie ?
    -   Le joueur dispose-t-il d’un nombre adéquat de pions sur le plateau ?
    -   Quel joueur domine au sens des poussées ? Existe-t-il un statuquo ?
    -   Quel joueur dispose des poussées avantageuses, c’est à dire déplaçant une montagne
        proche du bord ?

B. Explications
La notation du plateau est effectuée par le prédicat noter_plateau/2 qui associe une note à un
plateau. Pour ce faire, il calcule quatre notes intermédiaires et effectue une somme pondérée de
ces notes. C’est la pondération choisie pour chaque note qui va modifier le comportement de l’IA
et lui dicter ses priorités.

Plus une note est basse, moins le plateau est à l’avantage du joueur courant, plus la note est
haute, plus le joueur a intérêt à atteindre cet état.

Décrivons dans les sous-parties suivantes chacune des quatre heuristiques.

1. Plateau victorieux
C’est le prédicat un_vainqueur/2 qui est responsable du calcul de cette première note. Pour ce
faire, le prédicat vérifie si le plateau est victorieux, et si le joueur gagnant est le joueur courant
ou sn adversaire. La note associée peut donc être de 0 si personne ne gagne, ou de +/-1000 selon
qui gagne. Cette note très haute permet de classer automatiquement un plateau gagant ou
perdant comme le meilleur ou le pire plateau à jouer.

2. Nombre de pions
Nous partons du constat qu’il est possible d’optimiser le nombre de pions de chaque joueur sur
le plateau pour augmenter ses chances de gagner. Le prédicat des_pions_sur_le_plateau/2 permet
d’associer une note qui est fonction du nombre de pion qu’un joueur possède. En effet, avoir peu
de pions est gênant (0,1), en avoir trop est aussi une mauvaise chose ! En effet, si tous mes pions
sont sur le plateau, alors je ne pourrai pas en ajouter un à la dernière minute pour bloquer une
poussée ennemie. Avoir 2, 3 ou 4 pions sur le plateau optimise progressivement la note de
sortie.

En observant l’IA jouer, vous pourrez constater que dans certains cas un peu bouchés de fin de
partie, l’IA pense à sortir un pion pour pouvoir le re-rentrer ailleurs par la suite. De la même
façon, il arrive qu’en début de partie, l’IA cherche à rentrer au moins 2 ou 3 pions avant de
commencer à réellement pousser. Vous pouvez modifier ce comportement en atténuant ou
renforçant la pondération de la note N2 dans le prédicat noter_plateau/2 (de base, 0.3).




Friscira Elsa – Muller Marc                                                              P a g e | 11
Jeu de Siam
                                        V. Fichier Notation


3. Balance des poussées
Cette heuristique est constituée du prédicat orientation_visavis_montagnes/2. Ce prédicat un peu
complexe utilise les findall/3 pour se créer une liste de toutes les poussées possibles sur le
plateau pour chaque joueur. Le but est de connaître le nombre de montagnes que chaque joueur
est en mesure de pousser. Chaque poussée donne à son joueur une note positive, et à l’autre une
note négative. Si chaque joueur pousse autant de montagne, alors il y a statuquo.

Cette heuristique permet, entre deux plateaux, de se rendre compte que dans un cas, on bloque
une poussée ennemie (note globale nulle) alors que dans l’autre cas, chaque joueur peut pousser
quelque chose.

La création de ces listes de poussée n’est cependant pas aisée, car même si un pion peut pousser
quelque chose, rien ne nous dit qu’il s’agit forcément d’une montagne ou, pire, que nous sommes
réellement le gagnant dans cette poussée (si un ennemi est dans le bon sens et plus près de la
montagne, c’est à lui qu’appartient cette poussée).

Voici donc un findall utilisé et commenté :

findall(LPions,(
                member([Ori,Sens],E),          % (1)
                construire_liste_pions([E,R,M,J],LPions,Ori,Sens), % (2)
                length(LPions,A),      % (3)
                A>1,                   % (4)
                calculer_force(LPions,0,0),    % (5)
                derniere_montagne(LPions,Limite), % (6)
                chercher_camp_pousseur(E,R,M,Ori,Sens,Limite,'e') % (7)
        ),ListeE),


   -   1 : on sélectionne un pion du joueur E
   -   2 : on construit la liste de poussée en face de ce pion
   -   3 : on calcule la longueur de cette liste
   -   4 : si le pion était orienté vers une case vide, la liste de poussée ne contient que lui, on ne
       s’y intéresse pas
   -   5 : on vérifie que la poussée est possible
   -   6 : on récupère la position de la montagne la plus au bord de la poussée (s’il n’y a pas de
       montagne, le prédicat est faux, on ne compte pas cette poussée « inutile »).
   -   7 : on regarde si la poussée est bien gagnée par un joueur E

On répète la même opération pour le joueur R afin de disposer d’une liste par joueur ! On peut
ensuite appliquer une note à chacun en fonction du nombre de poussées et savoir qui est le
maître de la savane !

Notons qu’avant de comptabiliser les poussées, on supprime les poussées doublons. Exemple : si
j’ai un pion en 11, un pion en 21 et une montagne en 31 et que mes deux pions sont vers le nord,
alors j’aurai une liste de poussée pour le pion 11 et une liste pour le pion 21, ce qui va
augmenter ma note à tort. On utilise donc eliminer_poussees_identiques/3 qui est capable de
détecter et filtrer ces poussées identiques.




Friscira Elsa – Muller Marc                                                              P a g e | 12
Jeu de Siam
                                        V. Fichier Notation


Cette heuristique est très utile dans la note finale du plateau, elle permet de montrer à l’IA qu’un
coup va bloquer l’adversaire ou qu’un simple changement d’orientation va retourner la partie. Si
vous désirez jouer sur ce facteur, il est possible de modifier la pondération de la note N3 u
prédicat noter_plateau/2.

4. Intérêt des poussées
L’heuristique précédente ne serait pas complète sans l’ajout important réalisé par
montagnes_en_poussee_proche_bord/2, un prédicat au nom mystérieux mais qui permet d’ajouter
une dimension « d’utilité » au calcul des poussées.

En effet, pousser une montagne depuis le coin inférieur droit vers le haut est moins intéressant
que pousser une montagne située à une ou deux cases du bord. Pour prendre en compte cette
logique, nous réutilisons le mécanisme de construction des listes de poussées décrit dans la
partie ci-dessus mais y ajoutons un calcul de la distance entre la montagne la plus au bord ‘une
poussée et le bord du plateau situé dans la direction de poussée.

Encore une fois, c’est un findall/3 qui va nous permettre de créer ces listes. Pour chaque liste de
poussée, on va utiliser distance_bord_selon_orientation/3 pour connaître la distance restante à
parcourir en faisant bien attention à l’orientation. Exemple : une montagne en 25, poussée vers
le nord est certes à 0 case du bord droit du plateau, mais nous calculons la distance par rapport
au bord haut du plateau, soit 3 cases.

Cette heuristique associe à chaque distance une note qui est inversement proportionnelle au
carré de la distance (15/D² pour être exact).

Cette note permet à l’IA de choisir de pousser les « bonnes » lignes ou colonnes pour maximiser
ses chances de victoire, c’est à dire en rapprochant une montagne du bord, plutôt qu’en poussant
un peu n’importe où.

Vous pouvez jouer sur cette note en modifiant la pondération de la note N4 dans le prédicat
noter_plateau/2 (de base, pondération = 1.5).

C. Conclusion sur l’IA
Comme nous venons de le présenter, l’IA est capable de noter un plateau en tenant compte de
plusieurs paramètres qui nous paraissent importants. Néanmoins, cela ne fait pas de l’IA une
créature (de la savane) pensante et ne saurait lui permettre de jouer à la perfection. Nous
estimons cependant avoir réussi notre pari en proposant une IA qui joue bien, même en ne
prévoyant qu’à un coup !

Il est possible de jouer contre l’IA avec 1, 2 ou 3 coups de prévision. Notons que la version à 3
coups demande un temps de calculs de 5 à 25 secondes par tour. La façon dont l’optimisation est
effectuée est responsable de ce temps :

   -   Notre notation de plateau est un peu gourmande en calculs vu la masse de données
       vérifiées
   -   Notre algorithme de recherche inspiré du minimax n’est pas optimisé vu qu’il vérifie
       tous les coups à chaque niveau plutôt que de générer coup par coup et de s’arrêter dans
       une branche en fonction des notes déjà collectées.


Friscira Elsa – Muller Marc                                                            P a g e | 13
Jeu de Siam
                                           Conclusion


CONCLUSION
Ce projet P12 aura été très intéressant pour plusieurs raisons. Tout d’abord pour l’importante
auto-formation en Prolog qu’il a constitué pour nous. Le projet nous a été confié alors que nous
ne disposions d’aucune compétence dans le domaine et nous avons donc appris énormément,
du simple affichage du plateau aux algorithmes récursifs de recherches de coups ou de notation
de plateau.

Un autre intérêt du projet a été de pouvoir aborder les mécanismes de programmation logique
permettant de créer un jeu en formalisant ses règles ainsi que de la manière de concevoir une
intelligence artificielle en mesure de générer et de tester des coups.

Néanmoins, nous avons rencontré de nombreuses difficultés : manque de connaissance du
Prolog au début, apprentissage douloureux des mécanismes récursifs, des coupures, difficulté
de débogage des prédicats complexes.

Le bilan de ce projet n’en reste pas moins extrêmement positif !




Friscira Elsa – Muller Marc                                                         P a g e | 14

Contenu connexe

En vedette

Enrichir son programme d'immersion avec la technologie 2013
Enrichir son programme d'immersion avec la technologie 2013 Enrichir son programme d'immersion avec la technologie 2013
Enrichir son programme d'immersion avec la technologie 2013 MmeNero
 
Un livret pour les enfants sur la gratitude - A Little Children's book about ...
Un livret pour les enfants sur la gratitude - A Little Children's book about ...Un livret pour les enfants sur la gratitude - A Little Children's book about ...
Un livret pour les enfants sur la gratitude - A Little Children's book about ...Freekidstories
 
[Fr] mythes & réalité des médias sociaux - Dii
[Fr] mythes & réalité des médias sociaux - Dii[Fr] mythes & réalité des médias sociaux - Dii
[Fr] mythes & réalité des médias sociaux - DiiOrange
 
Ley 1620 del 15 de marzo de 2013
Ley 1620 del 15 de marzo de 2013Ley 1620 del 15 de marzo de 2013
Ley 1620 del 15 de marzo de 2013Nubesperan2015
 
Dans la maison de ton cœur
Dans la maison de ton cœurDans la maison de ton cœur
Dans la maison de ton cœurFreekidstories
 
Panorama de la presse développement durable
Panorama de la presse développement durablePanorama de la presse développement durable
Panorama de la presse développement durableSC Conseil
 
Theoreme de thales
Theoreme de thalesTheoreme de thales
Theoreme de thalesjalissfat
 
Filosofos
FilosofosFilosofos
Filosofosmagitaa
 
Le podcasting au service de l’apprentissage des langues étrangères
Le podcasting  au service de l’apprentissage  des langues étrangèresLe podcasting  au service de l’apprentissage  des langues étrangères
Le podcasting au service de l’apprentissage des langues étrangèresCaféine.Studio
 
2009 Circuit du médicament et collaboration en milieu carcéral
2009 Circuit du médicament et collaboration en milieu carcéral2009 Circuit du médicament et collaboration en milieu carcéral
2009 Circuit du médicament et collaboration en milieu carcéralAPRHOC
 
GeckoData Predict, solution d'analyse de données
GeckoData Predict, solution d'analyse de donnéesGeckoData Predict, solution d'analyse de données
GeckoData Predict, solution d'analyse de donnéesNP6
 
Enrichir son programme d'immersion avec l'internet
Enrichir son programme d'immersion avec l'internetEnrichir son programme d'immersion avec l'internet
Enrichir son programme d'immersion avec l'internetMmeNero
 
Numero special aout 2012 sur la gazelle
Numero special aout 2012 sur la gazelleNumero special aout 2012 sur la gazelle
Numero special aout 2012 sur la gazelleAdama Diaby
 
Carlos et isabel
Carlos et isabelCarlos et isabel
Carlos et isabelanaisruiz
 
Trabajo en equipo
Trabajo en equipoTrabajo en equipo
Trabajo en equipola_20cuervo
 

En vedette (20)

Euro matrixplus
Euro matrixplusEuro matrixplus
Euro matrixplus
 
Enrichir son programme d'immersion avec la technologie 2013
Enrichir son programme d'immersion avec la technologie 2013 Enrichir son programme d'immersion avec la technologie 2013
Enrichir son programme d'immersion avec la technologie 2013
 
Un livret pour les enfants sur la gratitude - A Little Children's book about ...
Un livret pour les enfants sur la gratitude - A Little Children's book about ...Un livret pour les enfants sur la gratitude - A Little Children's book about ...
Un livret pour les enfants sur la gratitude - A Little Children's book about ...
 
[Fr] mythes & réalité des médias sociaux - Dii
[Fr] mythes & réalité des médias sociaux - Dii[Fr] mythes & réalité des médias sociaux - Dii
[Fr] mythes & réalité des médias sociaux - Dii
 
Ley 1620 del 15 de marzo de 2013
Ley 1620 del 15 de marzo de 2013Ley 1620 del 15 de marzo de 2013
Ley 1620 del 15 de marzo de 2013
 
Dans la maison de ton cœur
Dans la maison de ton cœurDans la maison de ton cœur
Dans la maison de ton cœur
 
Panorama de la presse développement durable
Panorama de la presse développement durablePanorama de la presse développement durable
Panorama de la presse développement durable
 
Theoreme de thales
Theoreme de thalesTheoreme de thales
Theoreme de thales
 
Filosofos
FilosofosFilosofos
Filosofos
 
Le podcasting au service de l’apprentissage des langues étrangères
Le podcasting  au service de l’apprentissage  des langues étrangèresLe podcasting  au service de l’apprentissage  des langues étrangères
Le podcasting au service de l’apprentissage des langues étrangères
 
2009 Circuit du médicament et collaboration en milieu carcéral
2009 Circuit du médicament et collaboration en milieu carcéral2009 Circuit du médicament et collaboration en milieu carcéral
2009 Circuit du médicament et collaboration en milieu carcéral
 
Cp etude cda2013
Cp etude cda2013Cp etude cda2013
Cp etude cda2013
 
Test qi
Test qiTest qi
Test qi
 
GeckoData Predict, solution d'analyse de données
GeckoData Predict, solution d'analyse de donnéesGeckoData Predict, solution d'analyse de données
GeckoData Predict, solution d'analyse de données
 
Enrichir son programme d'immersion avec l'internet
Enrichir son programme d'immersion avec l'internetEnrichir son programme d'immersion avec l'internet
Enrichir son programme d'immersion avec l'internet
 
Numero special aout 2012 sur la gazelle
Numero special aout 2012 sur la gazelleNumero special aout 2012 sur la gazelle
Numero special aout 2012 sur la gazelle
 
Carlos et isabel
Carlos et isabelCarlos et isabel
Carlos et isabel
 
Test presentation
Test presentationTest presentation
Test presentation
 
Trabajo en equipo
Trabajo en equipoTrabajo en equipo
Trabajo en equipo
 
proyecto de aprendizaje 1 A Rania ortega
proyecto de aprendizaje 1 A Rania ortegaproyecto de aprendizaje 1 A Rania ortega
proyecto de aprendizaje 1 A Rania ortega
 

Similaire à Ia02 friscira muller_rapport

Berlin XVIII - Livre de règles 1ed.pdf
Berlin XVIII - Livre de règles 1ed.pdfBerlin XVIII - Livre de règles 1ed.pdf
Berlin XVIII - Livre de règles 1ed.pdfedrickdestroy
 
Presentation gamification
Presentation gamificationPresentation gamification
Presentation gamificationAppstud
 
Rapport de Soutenance 3
Rapport de Soutenance 3Rapport de Soutenance 3
Rapport de Soutenance 3BartOunay
 
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...Achraf Frouja
 
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)lincubateur_tls
 

Similaire à Ia02 friscira muller_rapport (11)

AI Mastermind f.pdf
AI Mastermind f.pdfAI Mastermind f.pdf
AI Mastermind f.pdf
 
Berlin XVIII - Livre de règles 1ed.pdf
Berlin XVIII - Livre de règles 1ed.pdfBerlin XVIII - Livre de règles 1ed.pdf
Berlin XVIII - Livre de règles 1ed.pdf
 
Presentation gamification
Presentation gamificationPresentation gamification
Presentation gamification
 
QQCOQP_minijeu_Document-Navigateur_V1
QQCOQP_minijeu_Document-Navigateur_V1QQCOQP_minijeu_Document-Navigateur_V1
QQCOQP_minijeu_Document-Navigateur_V1
 
Procrastinagame
ProcrastinagameProcrastinagame
Procrastinagame
 
QQCOQP-Document_animateur_Tome2
QQCOQP-Document_animateur_Tome2QQCOQP-Document_animateur_Tome2
QQCOQP-Document_animateur_Tome2
 
Gdd 23 05
Gdd 23 05Gdd 23 05
Gdd 23 05
 
Rapport de Soutenance 3
Rapport de Soutenance 3Rapport de Soutenance 3
Rapport de Soutenance 3
 
A14 02-tutoriel glup
A14 02-tutoriel glupA14 02-tutoriel glup
A14 02-tutoriel glup
 
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...
Présentation : Projet de Fin d'etude ' PFE ' 2018 : Conception et Réalisation...
 
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)
Incubateur Toulousain - Introduction au XNA - Damien Paludetto (26/01/2011)
 

Plus de Elsa Friscira

Draw In The Air Android App
Draw In The Air Android AppDraw In The Air Android App
Draw In The Air Android AppElsa Friscira
 
GroupFun HCI Lab - EPFL
GroupFun HCI Lab - EPFL GroupFun HCI Lab - EPFL
GroupFun HCI Lab - EPFL Elsa Friscira
 
GroupFun design process poster
GroupFun design process posterGroupFun design process poster
GroupFun design process posterElsa Friscira
 
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for Development
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for DevelopmentACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for Development
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for DevelopmentElsa Friscira
 

Plus de Elsa Friscira (6)

Draw In The Air Android App
Draw In The Air Android AppDraw In The Air Android App
Draw In The Air Android App
 
GroupFun HCI Lab - EPFL
GroupFun HCI Lab - EPFL GroupFun HCI Lab - EPFL
GroupFun HCI Lab - EPFL
 
GroupFun design process poster
GroupFun design process posterGroupFun design process poster
GroupFun design process poster
 
Logo
LogoLogo
Logo
 
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for Development
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for DevelopmentACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for Development
ACM DEV '12 Proceedings of the 2nd ACM Symposium on Computing for Development
 
ACM Dev 2012
ACM Dev 2012ACM Dev 2012
ACM Dev 2012
 

Ia02 friscira muller_rapport

  • 1. Jeu de Siam IA02 – Projet 2012 Création d’un système de jeu complet incluant une intelligence artificielle. ELSA FRISCIRA MARC MULLER Les éléphants et les rhinocéros s'affrontent dans une lutte sans merci. Les animaux se déplacent sur le plateau et poussent des montagnes selon des règles de rapport de force bien précises. Le but est d'être le premier joueur qui sort une montagne du plateau.
  • 2. Jeu de Siam Introduction INTRODUCTION Le projet de l’uv IA02 pour le semestre de printemps 2012 consiste à reproduire au moyen du langage Prolog un logiciel permettant de jouer au jeu du Siam. Ce jeu devra permettre de s’affronter entres humains ou bien de défier l’intelligence artificielle qui est à développer avec le jeu. Le jeu de Siam est un jeu où deux joueurs tentent de pousser des montagnes hors d’un plateau de taille 5x5. Les pions peuvent se pousser entre eux et tenter de se bloquer. Malgré un plateau de taille réduite, les possibilités de coup sont légions car chaque pion dispose également d’une orientation sur sa case. Nous allons présenter l’organisation de notre programme, décrire le fonctionnement des prédicats principaux. Nous poursuivrons en présentant l’intelligence artificielle incluse et les choix d’heuristiques faits. Enfin, nous présenterons les difficultés rencontrées au cours de ce projet. SOMMAIRE Introduction ........................................................................................................................................................................ 2 Sommaire ............................................................................................................................................................................. 2 Note importante ................................................................................................................................................................ 3 I. Organisation du programme .................................................................................................................................... 4 II. Fichier BASE................................................................................................................................................................... 4 A. Contenu ................................................................................................................................................................. 4 B. Explications ......................................................................................................................................................... 4 C. Structures de données..................................................................................................................................... 6 III. Fichier Mécanismes ................................................................................................................................................... 7 A. Contenu ................................................................................................................................................................. 7 B. Explications ......................................................................................................................................................... 7 C. Structures de données..................................................................................................................................... 8 IV. Fichier IA ........................................................................................................................................................................ 9 A. Contenu ................................................................................................................................................................. 9 B. Explications ......................................................................................................................................................... 9 V. Fichier Notation .......................................................................................................................................................... 11 A. Contenu ............................................................................................................................................................... 11 B. Explications ....................................................................................................................................................... 11 C. Conclusion sur l’IA .......................................................................................................................................... 13 Conclusion .......................................................................................................................................................................... 14 Friscira Elsa – Muller Marc Page| 2
  • 3. Jeu de Siam Note importante NOTE IMPORTANTE Nous commençons ce rapport par une note importante : nous nous sommes aperçus très peu de temps avant le rendu du projet qu’une règle manquait à notre jeu. Il s’agit du fait qu’un pion puisse rentrer sur le plateau en poussant un pion. Cette règle n’a pas été implémentée suite à une incompréhension des règles du jeu (nous avions compris l’inverse !). Cependant, nous avons réalisé notre erreur tard et avons décidé de ne pas la corriger pour deux raisons : - ajouter si tard une règle dans le jeu serait le meilleur moyen de ne pas pouvoir la tester entièrement et cela pourrait donc induire des instabilités ou des erreurs dans le jeu - l’intelligence artificielle a été développée sans connaître cette règle, et il serait long de lui en faire part tout en optimisant la pondération des heuristiques décrites dans la partie V. Le jeu contre l’IA serait faussé. Nous nous excusons donc de ce manque et souhaitons malgré cela un bon jeu au testeur de notre programme. Friscira Elsa – Muller Marc Page| 3
  • 4. Jeu de Siam I. Organisation du programme I. ORGANISATION DU PROGRAMME Notre programme Prolog est décomposé en quatre fichiers sources, contenant chacun une section différente des mécanismes du jeu. Pour lancer une partie du jeu, il faut tout d’abord charger chacun des quatre fichiers. Une fois cette opération effectuée, il faut appeler le prédicat lancer_jeu/0 qui va alors présenter un menu de jeu permettant de tester les différents types de parties ! | ?- lancer_jeu. ----- ----- ----- Choisissez le type de partie : - 1 : Humain contre humain - 2 : Humain contre IA - 3 : IA contre IA - 4 : Humain contre IA (version avec recherche de profondeur 2) - 5 : IA contre IA (version avec recherche de profondeur 2) - 6 : Humain contre IA (version avec recherche de profondeur 3) - 7 : IA contre IA (version avec recherche de profondeur 3) - 8 : Quitter II. FICHIER BASE A. Contenu Le fichier s’intitule en réalité « ia02_friscira_muller_BASE.pl ». Dans ce premier fichier, on retrouve les prédicats de base du jeu. Il s’agit principalement de : - Le menu de lancement de partie - Les prédicats de chargement et de sauvegarde du plateau de jeu - La boucle de jeu - Les prédicats d’affichage B. Explications 1. La boucle de jeu Le prédicat constituant la boucle de jeu est le prédicat jouer/0. Ce prédicat commence par charger le plateau courant grâce au prédicat dynamique plateau/1 et affiche ce plateau au joueur afin qu’il puisse étudier la situation. Suite à cela, le prédicat utilise repeat/0 pour créer une boucle qui va permettre au joueur de saisir un coup, jusqu’à ce que celui-ci soit valide. Dans cette boucle, nous demandons au joueur d’entrer son coup sous la forme [Origine, Destination, Orientation], lisons ce coup et vérifions s’il est possible grâce à coup_possible/3. Tant que le coup n’est pas possible, le prédicat renvoi faux et la boucle recommence. Si le coup est possible, on avance dans le prédicat jouer et on applique le coup du joueur. Ensuite, on vérifie si le plateau résultant est vainqueur. Si tel est le cas, un message spécial s’affiche, et la boucle de jeu s’interrompt car +victoire renvoi faux. Le joueur se retrouve alors Friscira Elsa – Muller Marc Page| 4
  • 5. Jeu de Siam II. Fichier BASE sur le menu général du jeu, prêt à lancer une revanche ! Dans le cas contraire, si +victoire renvoi vrai, c'est-à-dire que personne n’a gagné, alors on trouve qui est le prochain jouer grâce à autre_joueur/2 et on sauvegarde le plateau grâce à set_plateu/1. Enfin, on « cut » pour s’assurer que l’itération suivante de boucle ne revienne pas en arrière et on rappelle le prédicat jouer/0. Résumé : - Chargement et affichage du plateau - Lecture d’un coup possible - Application du coup - Vérification de fin de partie - Changement de joueur, sauvegarde du plateau Il existe deux autres versions de la boucle de jeu. La seconde version, nommée jouer_hu_ia/1 est une version à deux clauses qui permet de jouer une partie humain contre IA. L’une des clauses permet de faire jouer l’humain, celle-ci est strictement identique à jouer/0. L’autre clause permet à l’IA de jouer, voici son fonctionnement : Le début du tour se déroule de la même façon, on charge le plateau et on l’affiche. Ensuite, l’IA fait appel à trouver_coup/4 qui est un prédicat qui va chercher le meilleur coup à jouer en cherchant jusqu’à une certaine profondeur de coup. Une fois ce coup trouvé, la boucle de jeu fonctionne similairement à celle du jeu humain. La troisième version de la boucle de jeu est la version jouer_ia_ia/1 qui permet de faire jouer l’ordinateur contre lui-même. Cette version ne contient qu’une seule clause strictement identique à la clause du jeu IA du prédicat jouer_hu_ia/1 décrit ci-dessus. Pour plus de détails, consulter le code documenté du fichier BASE. 2. L’affichage du plateau Quelques mots sur l’affichage du plateau. Celui-ci est possible via l’appel d’afficher_plateau/1. Ce prédicat en rappelle tout de suite un autre, qui est afficher_plateau/2 en lui communiquant la case à partir de laquelle commencer l’affichage (le coin supérieur gauche). Le prédicat est constitué de multiples clauses, qui permettent, au moyen de simples tests, de gérer les débuts et les fins de lignes. En effet, si on affiche la première case d’une ligne, on trace le contour supérieur des cases ; dans le même esprit, en fin de ligne, on trace la base de la ligne. Chaque appel réalise un affichage et fait évoluer le numéro de case courante pour l’appel suivant. Chaque case est affichée au moyen des prédicats afficher_case/2 et afficher_orientation/1. Friscira Elsa – Muller Marc Page| 5
  • 6. Jeu de Siam II. Fichier BASE Figure 1 : Aperçu du plateau de jeu initial 3. Autres prédicats Le prédicat lancer_jeu/0 est le prédicat racine, a appeler pour lancer une partie du jeu. Il s’agit d’un simple menu qui initialise le plateau et donne la main à une boucle de jeu. Le prédicat membre_alea/2 permet de choisir un élément au hasard dans une liste. Cela sera très utile pour choisir entre deux coups à jouer semblables. C. Structures de données Terminons l’analyse de ce fichier en présentant les structures de données introduites. 1. Plateau de jeu La structure du plateau de jeu est la suivante : [E,R,M,J], c'est-à-dire une liste contenant tout d’abord deux listes de pions E et R ou chacun des 5 éléments est de la forme [Case, Orientation]. La liste M est une liste des trois montagnes du jeu, par exemple [32,33,34] initialement. J est une variable contenant l’identifiant du joueur courant, par exemple ‘e’ pour éléphant ou ‘r’ pour rhinocéros. Exemple : [ [ [51,n],[23,s],[0,n],[12,o],[0,n] ],[ [11,e],[0,n],[35,o],[36,s],[0,n] ],[33,55,34],'e'] est un plateau ou chaque camp dispose de trois pions sur le plateau et ou c’est au joueur e de jouer. 2. Coup Un coup est une action effectuée par un joueur à un tour. Le coup est représenté par la liste suivante : [Origine, Destination, Orientation] avec Origine la position du pion à déplacer, Destination la position à laquelle envoyer ce pion et Orientation l’orientation d’arrivée du pion. Exemple : [0, 11, 'n'] est le coup qui consiste à entrer un pion sur le plateau en 11 vers le Nord. Friscira Elsa – Muller Marc Page| 6
  • 7. Jeu de Siam III. Fichier Mécanismes III. FICHIER MECANISMES A. Contenu Le fichier s’intitule en réalité « ia02_friscira_muller_MECANISMES.pl ». Dans ce second fichier, on retrouve les prédicats permettant de vérifier que les coups sont possibles et de les appliquer. Il s’agit principalement de vérifier : - L’orientation d’un coup - La validité des déplacements - L’état de la case d’arrivée - Les entrées/sorties du plateau - Les poussées et les rapports de force - La fin de partie B. Explications Le prédicat central de ce nouveau fichier est le prédicat coup_possible/3. Son rôle est de s’assurer que compte tenu d’un plateau donné, un coup est possible, et, si tel est le cas, de fournir les mouvements résultants de ce coup (un coup simple ne provoquera qu’un mouvement, un coup impliquant une poussée provoquera une liste de mouvement de translation). Cette liste de mouvements fournie par coup_possible/3 sera nommée dans le projet « Impact ». 1. Coup possible, fonctionnement général Le prédicat contient plusieurs clauses. Outre les trois premières qui sont des cas limites (comme celui de quitter la partie ou de faire du surplace), intéressons-nous surtout aux deux dernières clauses. On commence par vérifier le coup c'est-à-dire confirmer qu’il est bien orthogonal. On s’assure en suite que le pion à déplacer appartient au joueur courant. Si la case d’arrivée est libre, le prédicat est achevé et on renvoi un impact composé uniquement du coup. En revanche, si la case de destination est occupée, on est redirigé sur la dernière clause qui va, elle, engager une démarche pour vérifier que la poussée est possible. Après avoir vérifié que le pion était déjà dans l’orientation souhaitée pour la poussée, on construit une liste de poussée (cf. structures de données) et on vérifie que le rapport de force est en la faveur du joueur, si oui, on renvoie un impact contenant tous les déplacements, sinon, coup_possible est faux. La première clause permet de quitter le jeu, la seconde d’empêcher de bouger de 0 vers 0, et la troisième d’empêcher de rester sur place sans changer d’orientation. 2. Construction de liste de poussée Il est nécessaire dans le cas d’une poussée de se construire une liste de poussée permettant d’évaluer le rapport de force. Pour ce faire, on utilise le prédicat construire_liste_pions/4. Ce prédicat utilise le plateau, l’origine de la poussée et son orientation pour construire notre fameuse liste de poussée. Le fonctionnement est le suivant : on étudie la case sur laquelle on est. En fonction de l’orientation du pion qui s’y trouve, on ajoute à la liste de poussée un élément contenant un ‘+’, ou ‘-‘, un espace ou un ‘M’. Puis, on calcule quelle est la case suivante dans la poussée et on Friscira Elsa – Muller Marc Page| 7
  • 8. Jeu de Siam III. Fichier Mécanismes rappelle le prédicat. En fin de récursion, on a construit une liste contenant chaque pion sur son chemin et sa contribution à la poussée (positive, négative, neutre ou montagne). 3. Evaluation du rapport de force Quand on dispose d’une liste de poussée, on peut utiliser le prédicat calculer_force/3 pour nous dire si la poussée est possible. Calculer force analyse la liste de poussée dans l’ordre, et entretien deux compteurs : l’un de force et l’autre de poids. La force augmente et diminue pour chaque pion ayant une contribution positive ou négative. Le poids augmente pour chaque montagne. A chaque itération, la force doit surpasser le poids (>=) et en fin de calcul, la force doit être non nulle. 4. Détection de fin de partie Le prédicat victoire/4 permet de vérifier si le plateau est vainqueur. Le prédicat commence par vérifier qu’une montagne a bien été sortie du plateau grâce à montagne_hors_limite/2. Ensuite, il cherche qui a gagné en commençant par rechercher l’animal « poussant », c'est-à-dire le pion ayant une contribution positive le plus proche de la montagne qui a été sortie. Enfin, il utilise equipe/4 pour savoir à quel camp appartenait ce pion. C. Structures de données Quelques structures de données nouvelles ont été introduites. 1. Impact Un impact est une liste de mouvements que l’on récupère grâce à coup_possible/3. Cette liste de mouvements peut donc ensuite être appliquée à un plateau pour déplacer un par un chacun des pions impactés par un coup. Chaque élément de la liste Impact contient l’origine du pion, sa destination et son orientation d’arrivée. Exemple : [ [11, 21, ‘n’], [21, 31, ’e’], [31, 41, ’e’]] est un Impact ou trois pions sont déplacés, à priori par le premier d’entre eux, situé en 11. 2. Liste de poussée Une liste de poussée est une structure permettant de décrire une ligne/colonne de poussée. Chaque élément est caractérisé par la position du pion, sa contribution à la poussée et son orientation. L’orientation n’a pas de réelle utilité dans les prédicats qui analysent une poussée, MAIS permet de très facilement reconstruire un impact à partir d’une liste de poussée. Exemple : [ [52, '+', 's'], [42, ' ', 'e'], [32, '+', 's'], [22, '-', 'n'], [52, 'M', 'M'] ] est une liste composée de quatre pions et une montagne. Deux des pions contribuent positivement au mouvement (‘+’) tandis qu’un autre gêne le mouvement (‘-‘) et qu’un autre est neutre (‘ ‘). Friscira Elsa – Muller Marc Page| 8
  • 9. Jeu de Siam IV. Fichier IA IV. FICHIER IA A. Contenu Le fichier s’intitule en réalité « ia02_friscira_muller_IA.pl ». Dans ce troisième fichier, on retrouve les prédicats en charge de gérer l’intelligence artificielle du jeu, c'est-à-dire : - Trouver les coups potentiels - Filtrer les coups pour réduire la combinatoire - Construire un arbre de recherche du meilleur coup B. Explications Nous allons présenter trois prédicats centraux. 1. Trouver les coups possibles Le prédicat coups_possible/3 est un prédicat en mesure de trouver pour un plateau donné tous les coups possibles avec leurs impacts respectifs et les plateaux générés par ces impacts. Ce prédicat commence par lister tous les coups potentiels pour le joueur courant, c’est à dire en proposant chaque déplacement orthogonal pour chaque pion et chaque orientation (et les cas de rotation sur place), ainsi que les coups d’entrée ou de sortie de plateau. C’est le prédicat coups_potentiels_joueur/2 qui créé cette longue liste. Ensuite, coups_possible demande à réduire la quantité de ces coups. En effet, il existe naturellement des doublons et des coups inutiles dont on peut se séparer pour atténuer la masse de coups à envisager. C’est le prédicat reduire_coups_possibles/3 qui est en charge de ce travail, et qui est expliqué dans la partie suivante (2.). Une fois les coups filtrés pour ne conserver que ceux qui semblent intéressants, un second filtrage permet de ne conserver que ceux qui sont effectivement possibles compte tenu de plateau de jeu. Enfin, le prédicat retourne les coups, impacts et plateaux de jeux issus des coups possibles. 2. Réduire le nombre de coups possibles Pour réduire le nombre de coups possibles, le prédicat reduire_coups_possibles/3 utilise une succession de sous-prédicats effectuant un traitement particulier. La première tâche est de supprimer les doublons. En effet, si le joueur dispose de deux pions hors du plateau, la liste des coups potentiels contient les mêmes mouvements pour chacun de ces pions. La seconde tâche consiste à nettoyer les coups qui sortent du plateau pour n’en conserver qu’un par pion, puisqu’il est strictement identique qu’un pion en 55 sorte vers le haut ou vers la droite. La troisième tâche consiste à supprimer les rotations inutiles. Le prédicat supprimer_rotations_inutiles/3 analyse pour chaque rotation sur place si elle a du sens. Une telle rotation n’a du sens que si le pion jouxte une case occupée. Ce choix est discutable car sur plus d’un tour, une rotation sur place peut changer le déroulement d’une partie, mais nous choisissons de filtrer ces coups pour réduire la combinatoire du jeu. Si je suis en case 11, s’il n’y Friscira Elsa – Muller Marc Page| 9
  • 10. Jeu de Siam IV. Fichier IA a personne en 12 et en 21, alors je ne conserve pas les coups opérant une rotation sur moi- même. La quatrième étape consiste à filtrer les déplacements ayant la même destination mais une orientation différente afin de ne conserver qu’une orientation d’arrivée si l’on juge que celle-ci n’a pas d’importance pour le jeu. C'est-à-dire, que si je suis en 31, et que je vais en 32, alors si toutes les cases autour de mon arrivée sont vides, je ne vais pas garder les quatre coups me conduisant en 32, mais seulement celui qui conserve mon orientation actuelle. Encore une fois, ce choix est discutable sur le long terme, mais c’est un sacrifice que nous consentons. 3. Trouver le meilleur coup à jouer Le prédicat trouver_coup/4 fait le lien avec le dernier fichier, il permet de choisir le meilleur coup à jouer en analysant les coups possibles futurs. Fonctionnement général : pour le plateau passé en argument, on va chercher tous les coups possibles et les plateaux résultants, et on va rappeler notre prédicat récursivement sur chacun de ces plateaux. On communique au prédicat le niveau courant de recherche. On peut par exemple appeler le prédicat avec un niveau de 3, et à chaque appel récursif, ce nombre est décrémenté. On atteindra donc le bas de l’arbre en 3 appels. Une fois le bas de l'arbre atteint (Niveau = 1), on note chaque plateau possible grâce au prédicat noter_plateau/2 qui sera présenté en V et on retient le coup qui a généré le meilleur plateau. On fait remonter sa note au niveau de récursion supérieur. On utilise ensuite un fonctionnement « minimax ». A chaque niveau, le prédicat va soit retenir la note maximale, soit la note minimale (avec le coup qui l'a générée et la note en question). En alternant minimisation et maximisation, on simule le fait que quand A prévoit son coup, il tente de maximiser ses coups et part du principe que B va maximiser lui aussi ses propres coups, ce qui revient à minimiser le coup du point de vue de A. Avec un simple test de parité sur Niveau, on sait donc si le prédicat doit faire le min ou le max des coups possibles à son niveau. Une fois revenu au niveau le plus haut de la recherche, on retient donc le Coup de base qui a conduit à la solution (feuille de l'arbre) la plus intéressante au travers d’une recherche à N niveaux. Friscira Elsa – Muller Marc P a g e | 10
  • 11. Jeu de Siam V. Fichier Notation V. FICHIER NOTATION A. Contenu Le fichier s’intitule en réalité « ia02_friscira_muller_NOTATION.pl ». Dans ce dernier fichier, on retrouve les prédicats en mesure de noter un plateau en suivant plusieurs heuristiques : - Le plateau conduit il à une fin de partie ? - Le joueur dispose-t-il d’un nombre adéquat de pions sur le plateau ? - Quel joueur domine au sens des poussées ? Existe-t-il un statuquo ? - Quel joueur dispose des poussées avantageuses, c’est à dire déplaçant une montagne proche du bord ? B. Explications La notation du plateau est effectuée par le prédicat noter_plateau/2 qui associe une note à un plateau. Pour ce faire, il calcule quatre notes intermédiaires et effectue une somme pondérée de ces notes. C’est la pondération choisie pour chaque note qui va modifier le comportement de l’IA et lui dicter ses priorités. Plus une note est basse, moins le plateau est à l’avantage du joueur courant, plus la note est haute, plus le joueur a intérêt à atteindre cet état. Décrivons dans les sous-parties suivantes chacune des quatre heuristiques. 1. Plateau victorieux C’est le prédicat un_vainqueur/2 qui est responsable du calcul de cette première note. Pour ce faire, le prédicat vérifie si le plateau est victorieux, et si le joueur gagnant est le joueur courant ou sn adversaire. La note associée peut donc être de 0 si personne ne gagne, ou de +/-1000 selon qui gagne. Cette note très haute permet de classer automatiquement un plateau gagant ou perdant comme le meilleur ou le pire plateau à jouer. 2. Nombre de pions Nous partons du constat qu’il est possible d’optimiser le nombre de pions de chaque joueur sur le plateau pour augmenter ses chances de gagner. Le prédicat des_pions_sur_le_plateau/2 permet d’associer une note qui est fonction du nombre de pion qu’un joueur possède. En effet, avoir peu de pions est gênant (0,1), en avoir trop est aussi une mauvaise chose ! En effet, si tous mes pions sont sur le plateau, alors je ne pourrai pas en ajouter un à la dernière minute pour bloquer une poussée ennemie. Avoir 2, 3 ou 4 pions sur le plateau optimise progressivement la note de sortie. En observant l’IA jouer, vous pourrez constater que dans certains cas un peu bouchés de fin de partie, l’IA pense à sortir un pion pour pouvoir le re-rentrer ailleurs par la suite. De la même façon, il arrive qu’en début de partie, l’IA cherche à rentrer au moins 2 ou 3 pions avant de commencer à réellement pousser. Vous pouvez modifier ce comportement en atténuant ou renforçant la pondération de la note N2 dans le prédicat noter_plateau/2 (de base, 0.3). Friscira Elsa – Muller Marc P a g e | 11
  • 12. Jeu de Siam V. Fichier Notation 3. Balance des poussées Cette heuristique est constituée du prédicat orientation_visavis_montagnes/2. Ce prédicat un peu complexe utilise les findall/3 pour se créer une liste de toutes les poussées possibles sur le plateau pour chaque joueur. Le but est de connaître le nombre de montagnes que chaque joueur est en mesure de pousser. Chaque poussée donne à son joueur une note positive, et à l’autre une note négative. Si chaque joueur pousse autant de montagne, alors il y a statuquo. Cette heuristique permet, entre deux plateaux, de se rendre compte que dans un cas, on bloque une poussée ennemie (note globale nulle) alors que dans l’autre cas, chaque joueur peut pousser quelque chose. La création de ces listes de poussée n’est cependant pas aisée, car même si un pion peut pousser quelque chose, rien ne nous dit qu’il s’agit forcément d’une montagne ou, pire, que nous sommes réellement le gagnant dans cette poussée (si un ennemi est dans le bon sens et plus près de la montagne, c’est à lui qu’appartient cette poussée). Voici donc un findall utilisé et commenté : findall(LPions,( member([Ori,Sens],E), % (1) construire_liste_pions([E,R,M,J],LPions,Ori,Sens), % (2) length(LPions,A), % (3) A>1, % (4) calculer_force(LPions,0,0), % (5) derniere_montagne(LPions,Limite), % (6) chercher_camp_pousseur(E,R,M,Ori,Sens,Limite,'e') % (7) ),ListeE), - 1 : on sélectionne un pion du joueur E - 2 : on construit la liste de poussée en face de ce pion - 3 : on calcule la longueur de cette liste - 4 : si le pion était orienté vers une case vide, la liste de poussée ne contient que lui, on ne s’y intéresse pas - 5 : on vérifie que la poussée est possible - 6 : on récupère la position de la montagne la plus au bord de la poussée (s’il n’y a pas de montagne, le prédicat est faux, on ne compte pas cette poussée « inutile »). - 7 : on regarde si la poussée est bien gagnée par un joueur E On répète la même opération pour le joueur R afin de disposer d’une liste par joueur ! On peut ensuite appliquer une note à chacun en fonction du nombre de poussées et savoir qui est le maître de la savane ! Notons qu’avant de comptabiliser les poussées, on supprime les poussées doublons. Exemple : si j’ai un pion en 11, un pion en 21 et une montagne en 31 et que mes deux pions sont vers le nord, alors j’aurai une liste de poussée pour le pion 11 et une liste pour le pion 21, ce qui va augmenter ma note à tort. On utilise donc eliminer_poussees_identiques/3 qui est capable de détecter et filtrer ces poussées identiques. Friscira Elsa – Muller Marc P a g e | 12
  • 13. Jeu de Siam V. Fichier Notation Cette heuristique est très utile dans la note finale du plateau, elle permet de montrer à l’IA qu’un coup va bloquer l’adversaire ou qu’un simple changement d’orientation va retourner la partie. Si vous désirez jouer sur ce facteur, il est possible de modifier la pondération de la note N3 u prédicat noter_plateau/2. 4. Intérêt des poussées L’heuristique précédente ne serait pas complète sans l’ajout important réalisé par montagnes_en_poussee_proche_bord/2, un prédicat au nom mystérieux mais qui permet d’ajouter une dimension « d’utilité » au calcul des poussées. En effet, pousser une montagne depuis le coin inférieur droit vers le haut est moins intéressant que pousser une montagne située à une ou deux cases du bord. Pour prendre en compte cette logique, nous réutilisons le mécanisme de construction des listes de poussées décrit dans la partie ci-dessus mais y ajoutons un calcul de la distance entre la montagne la plus au bord ‘une poussée et le bord du plateau situé dans la direction de poussée. Encore une fois, c’est un findall/3 qui va nous permettre de créer ces listes. Pour chaque liste de poussée, on va utiliser distance_bord_selon_orientation/3 pour connaître la distance restante à parcourir en faisant bien attention à l’orientation. Exemple : une montagne en 25, poussée vers le nord est certes à 0 case du bord droit du plateau, mais nous calculons la distance par rapport au bord haut du plateau, soit 3 cases. Cette heuristique associe à chaque distance une note qui est inversement proportionnelle au carré de la distance (15/D² pour être exact). Cette note permet à l’IA de choisir de pousser les « bonnes » lignes ou colonnes pour maximiser ses chances de victoire, c’est à dire en rapprochant une montagne du bord, plutôt qu’en poussant un peu n’importe où. Vous pouvez jouer sur cette note en modifiant la pondération de la note N4 dans le prédicat noter_plateau/2 (de base, pondération = 1.5). C. Conclusion sur l’IA Comme nous venons de le présenter, l’IA est capable de noter un plateau en tenant compte de plusieurs paramètres qui nous paraissent importants. Néanmoins, cela ne fait pas de l’IA une créature (de la savane) pensante et ne saurait lui permettre de jouer à la perfection. Nous estimons cependant avoir réussi notre pari en proposant une IA qui joue bien, même en ne prévoyant qu’à un coup ! Il est possible de jouer contre l’IA avec 1, 2 ou 3 coups de prévision. Notons que la version à 3 coups demande un temps de calculs de 5 à 25 secondes par tour. La façon dont l’optimisation est effectuée est responsable de ce temps : - Notre notation de plateau est un peu gourmande en calculs vu la masse de données vérifiées - Notre algorithme de recherche inspiré du minimax n’est pas optimisé vu qu’il vérifie tous les coups à chaque niveau plutôt que de générer coup par coup et de s’arrêter dans une branche en fonction des notes déjà collectées. Friscira Elsa – Muller Marc P a g e | 13
  • 14. Jeu de Siam Conclusion CONCLUSION Ce projet P12 aura été très intéressant pour plusieurs raisons. Tout d’abord pour l’importante auto-formation en Prolog qu’il a constitué pour nous. Le projet nous a été confié alors que nous ne disposions d’aucune compétence dans le domaine et nous avons donc appris énormément, du simple affichage du plateau aux algorithmes récursifs de recherches de coups ou de notation de plateau. Un autre intérêt du projet a été de pouvoir aborder les mécanismes de programmation logique permettant de créer un jeu en formalisant ses règles ainsi que de la manière de concevoir une intelligence artificielle en mesure de générer et de tester des coups. Néanmoins, nous avons rencontré de nombreuses difficultés : manque de connaissance du Prolog au début, apprentissage douloureux des mécanismes récursifs, des coupures, difficulté de débogage des prédicats complexes. Le bilan de ce projet n’en reste pas moins extrêmement positif ! Friscira Elsa – Muller Marc P a g e | 14