Le jeu de la tablette empoisonnée Dans le cadre de l UE HLIN405 - Iaroslav AMPLEEV, Antoine LAURENT, Nicolas POMPIDOR, Sacha WEILL - 25 avril 2015

Transcription

1 Le jeu de la tablette empoisonnée Dans le cadre de l UE HLIN405 - Iaroslav AMPLEEV, Antoine LAURENT, Nicolas POMPIDOR, Sacha WEILL - 25 avril 2015

2 Table des matières Introduction 2 1 Cahier des charges Règles du jeu Règles Exemple de partie Objectifs Réflexion Domaine de programmation Outils nécessaires La structure Les algorithmes Le paradigme de programmation Modélisation Modélisation Coup possible Première version Analyse Modélisation Construction de l arbre Coups possibles Evaluation des noeuds et parcours de l arbre Confrontation des deux structures Liaison avec l interface graphique 17 5 Conclusion 18 Table des figures 1 Tablette entière Découpage intérieur et en "escalier" impossible Premier coup d Albert Premier coup de Bertrand Second coup d Albert, de Bertrand puis troisième coup d Albert Troisième coup de Bertrand Découpage (2,2) Exemple de découpage interdit Schéma algorithmique IA Schéma de l arbre de jeu Le Negmax appliqué à l arbre de jeu Histogramme comparatif du nombre de noeuds Tableau comparatif du nombre de noeuds Histogramme comparatif de la rapidité de construction Tableau comparatif de la rapidité de construction

3 Introduction Dans le cadre de l UE HLIN405 (projet informatique) à l Université de Montpellier, il nous a été demandé de réaliser un projet informatique. Projet qui devait être choisi parmi une liste de sujets aussi variés les uns que les autres. Après avoir lu les différents sujets, nous avons décidé d opter pour la programmation d un jeu vidéo. En effet nous trouvons que le résultat d une telle application est visible et surtout plus amusant (pouvoir y jouer). Ainsi nous avons établi une liste contenant nos préférences, avec en premier, «Lecarréempoisonnédelatablettedechocolat»(sujetenannexe)supervisé par M. Dicky. Ce jeu avait l avantage de proposer à la fois une recherche d algorithme complexe (établir une intelligence artificielle qui gagne à tous les coups) et un objectif attractif (nous aimons tous manger du chocolat). Au final nous avons eu la chance d être affecté sur ce sujet et nous avons pu programmer le jeu. Afin de présenter notre travail, nous allons commencer par expliquer en détail les règles, en s appuyant sur une simulation de partie, ensuite nous allons détailler notre réflexion concernant la conception du jeu et les outils que nous allons utiliser. Enfin nous présenterons le cœur du projet, le fonctionnement de l intelligence artificielle et les deux versions différentes que nous avons développé au cours du semestre. Enfin, nous conclurons en présentant la liaison entre la partie algorithmique et graphique. 1 Cahier des charges 1.1 Règles du jeu Dans cette partie nous allons vous présenter les règles que notre encadrant nous a dit de suivre, en effet, elles diffèrent légèrement de celles dans la feuille du projet Règles Le carré empoisonné est un jeu qui confronte deux joueurs sur un plateau rectangulaire de taille variable. Le plateau représente une tablette de chocolat divisée en carrés dont l un d eux est empoisonné, il se situe dans un des coins de la tablette et sa position est connue des joueurs. Dans notre cas, la position est le coin inférieur gauche (exemple figure 1). Figure 1 Tabletteentière 2

4 Le but est de faire manger à l adversaire le carré de chocolat empoisonné afin que celui-ci perde la partie. Chacun leur tour les joueurs doivent découper un morceau de la tablette selon les règles suivantes : La zone mangée doit être un rectangle car lorsqu on mange un carré, les carrées situés au dessus et à sa droite sont mangés. Les bords supérieur et droit doivent être «libres», il est donc impossible de découper un morceau à l intérieur de la tablette (figure 2, premier exemple). On ne peut découper qu un rectangle plein, les zones en «escalier» ne peuvent être coupées (figure 2, second exemple). Figure 2 Découpageintérieureten"escalier" impossible Exemple de partie Nous allons présenter une partie jouée sur une tablette de taille 5*3 afin de mieux comprendre les règles. Appelons le premier joueur M.Albert et le second M.Bertrand. Le premier joueur, Albert, doit choisir un rectangle à découper selon les règles décrites précédemment, (voir (figure 3)) : Figure 3 Premiercoupd Albert C est au tour de Bertrand de jouer (voir figure 4 ): Figure 4 PremiercoupdeBertrand 3

5 Et ainsi de suite les joueurs jouent : Figure 5 Secondcoupd Albert,deBertrandpuistroisièmecoupd Albert Figure 6 TroisièmecoupdeBertrand Jusqu au dernier coup où la seule option est de manger le carré empoisonné. Albert perd donc cette partie car il ne lui reste plus de choix pour le carré à manger. 1.2 Objectifs Dans le cadre du projet, nous nous sommes fixés en plus l objectif de représenter ce jeu sur une interface vidéoludique afin de pouvoir y jouer à l aide d une souris, ce qui relève d une plus grande difficulté. De plus l implémentation du jeu doit permettre de jouer contre une intelligence artificielle dont la conception est complexe. Le projet présentait deux branches de travail : Écrire un programme qui soit bon mais pas infaillible. Écrire un programme qui gagne à chaque fois. Nous avons décidé de nous concentrer sur l IA imbattable, cette branche projet renfermant différentes difficultés au niveau du codage et tout particulièrement de l intelligence artificielle mais aussi au niveau de l ergonomie. Notre objectif adoncétéderéaliserunprogrammefonctionnel,simpled utilisationetidéalement beau. Pour résumer : Un jeu possédant une intelligence artificielle capable de trouver les coups gagnants. Un écran menu au départ proposant de modifier certaines options comme le son, la taille de la fenêtre, accéder aux crédits ou tout simplement commencer une partie. Des bruitages et des musiques. Un bouton pause. Des objets dessinés et parfois animés (sprites). Tout simplement, un jeu exaltant! 4

6 2 Réflexion Une I.A. dans les jeux de plateau peut théoriquement être imbattable, selon la personne qui commence, si le jeu en question répond à certains critères : Le jeu concerné possède un nombre de positions dénombrable (ce qui est le cas ici, même s il y a une infinité de tailles de plateau, chaque plateau aunnombrefinidepositions). Il n y a pas d égalité possible lors d une confrontation. Aucun facteur aléatoire propre aux règles du jeu existe (comme un dé ou un lancer de pièce). Le carré empoisonné possède donc une stratégie gagnante. Quand l IA commence, cette stratégie consiste à trouver un chemin qui, pour chaque coup joué mettra l adversaire dans une position perdante (c est à dire que tout coup suivant possible sera gagnant). Dans le cas où l IA ne commence pas, notre stratégie gagnante devra suivre le chemin où le joueur a le plus de chance de commettre une erreur et donc permettre à notre IA de reprendre un chemin gagnant. Une fois le sujet attribué il nous a fallu cibler le domaine informatique dans lequel évoluait ce projet. Nous nous sommes ensuite intéressés aux outils nécessaires dont nous avions besoin pour pouvoir réaliser ce projet. Enfin, nous avons choisi le paradigme de programmation qui nous semblait le plus approprié par rapport à ces critères. 2.1 Domaine de programmation Il est assez évident que le projet s inscrit dans le domaine des jeux. C est une catégorie importante dans le domaine de l informatique, elle est souvent caractérisée par l utilisation d intelligence artificielle. Dans notre cas nous nous sommes tournés vers une IA basée sur la théorie des jeux, et spécifiquement les jeux à somme nulle, un jeu où la somme des gains est égale à 0. C est à dire qu il ne peut y avoir qu un seul gagnant sur une partie àdeuxjoueurs. Par conséquent le joueur qui commence la partie (s il a une stratégie gagnante) peut finir victorieux. Il est facile d en faire la preuve par l absurde, si l on suppose que l IA a une stratégie gagnante et joue en premier, et que le joueur a aussi une stratégie gagnante quelque soit le coup joué par l IA. Supposons que l IA joue le coup gagnant A et ensuite le joueur joue le coup gagnant B, alors l IA aurait pu en commençant jouer le coup B, lui permettant de gagner. Ce qui est absurde. On voit bien que le joueur qui commence avec une stratégie gagnante, remporte la partie. 5

7 Après avoir défini le domaine informatique dans lequel évoluait le projet, il nous a fallu nous intéresser aux différents outils pour créer ce jeu. 2.2 Outils nécessaires La structure Une des premières réflexions a été de choisir la structure à adopter pour stocker la tablette et ses différents états. Le premier choix s est porté sur une matrice de booléens n*m où n serait la hauteur et m la largeur, ainsi on aurait connu l état de la tablette à chaque coup (1 s il-y-a du chocolat, 0 sinon). Mais on s est vite rendu compte qu utiliser un vecteur de taille l (largeur de la tablette) ayant, dans chacune de ses cases mémoires, la valeur de la hauteur, était plus simple algorithmiquement parlant et moins gourmand en terme de mémoire. De plus l utilisation de cette structure est plus pratique tant dans la manipulation au niveau du code que dans l implémentation de fonction telle que de savoir si un coup est possible. Ensuite pour stocker les coups possibles nous avons pensé, grâce à l aide de notre encadrant, à faire un arbre où tous les coups possibles seraient stockés àl avanceetensuiteyappliquerdesalgorithmesd explorationpourmettreen place notre stratégie gagnante. Notre premier jet fut l arbre contenant tous les coups possibles en distinguant les noeuds joueur et les noeuds IA pour chaque état de la tablette, ce qui dupliquait des sous arbres un nombre important de fois, prenant donc beaucoup de place et de temps de calcul. Pour y remédier nous avons penché pour une structure d arbre qui ne contenait qu une et une seule fois les différents états de la tablette, qu il nous faudra juste relier pour obtenir notre arbre de jeu et appliquer la stratégie gagnante dessus Les algorithmes Pour pouvoir appliquer notre solution gagnante à l arbre de jeu il nous a fallu réfléchir à plusieurs algorithmes : 1. Le Minimax : C est un algorithme récursif d exploration d arbre, qui prend en paramètre le joueur pour faire la distinction entre l IA et le joueur. L algorithme remonte à la racine une valeur située dans les feuilles ou donnée par une fonction d évaluation du noeud n eval1(n) qui dans notre cas retournera un booléeb (0 si le noeud est perdant et 1 sinon). 2. Le NegMax :LeNegmaxestunesimplificationduMinimax,quine fait pas la distinction entre les joueurs. Il fonctionne par symétrie par rapport à 0 où nous pouvons définir une nouvelle fonction d évaluation eval2(n) : eval2(n) =eval1(n) si nous sommes sur un noeud IA. eval2(n) = eval1(n) si nous sommes sur un noeud joueur. 6

8 3. Le Alpha Pruning :L AlphaPruningestunetechniquepermettant de réduire le nombre de noeuds évalués dans l arbre par l algorithme du Minimax ou Negmax. Il permet d élaguer (ou de ne pas explorer) des sous arbres dont la valeur ne contribuera pas au calcul du gain de la racine. 4. Savoir si un coup est possible : C est la fonction essentielle du programme, c est elle qui permet de savoir si le coup proposé par le joueur respecte les règles de découpage de la tablette. 2.3 Le paradigme de programmation Pour ce projet nous avions besoin d un langage permettant de modéliser les différents éléments du jeu (arbre, tablette, noeuds) et leurs relations. Nous avions également besoin de pouvoir créer plusieurs objets différents d un même type. De plus, dû à notre objectif de faire une interface graphique, par respect du domaine du jeu et par challenge de gestion de notre mémoire, nous nous sommes orientés vers le langage C++. Quant à l interface graphique, notre choix s est porté sur la SFML (Simple and Fast Multimedia Library), car c est un langage simple et rapide au niveau des initialisations et comprend moins de modules que la SDL. Maintenant que nous connaissons nos objectifs de réalisation et leurs outils, intéressons nous à la modélisation du jeu. 3 Modélisation 3.1 Modélisation 1 Une fois les règles du jeu comprises et le choix de représentation de la tablette effectué (un tableau/vecteur d entiers contenant pour chaque case la hauteur), nous avons réfléchi aux problèmes majeurs que nous allions rencontrer. Le premier est de définir la succession des coups, autrement dit comment savoir si à partir d un état X de la tablette on peut arriver à un état Y après un coup? De manière générale, comment savoir si un coup est possible? Le second concerne l intelligence artificielle, soit la fabrication de l arbre de jeu qui détermine les coups que jouera l ordinateur. Nous avons abordé ces problèmes dans cet ordre puisque lors de la conception du jeu nous avons décidé de le réaliser jouable par deux personnes humaines (d où la nécessité de définir les coups jouables) puis d y rajouter l IA. Nous allons donc détailler ces deux parties Coup possible Pour déterminer le coup à jouer, l ordinateur ou le joueur doit indiquer les coordonnées du carré inférieur gauche de la zone qu il veut découper. Par exemple dans la figure 7 les coordonnées de découpe sont (2,2). 7

9 Figure 7 Découpage(2,2) Chaque état de la tablette est représenté par une classe qui a entre autre un vecteur contenant les hauteurs de la tablette ainsi que la hauteur et la largeur de la tablette originale. C est avec ces informations et les coordonnées du coup que nous allons vérifier s il est possible. La première est de s assurer que l on ne découpe pas dans le «vide», c est à dire que l abscisse ne se situe pas à un endroit où la hauteur est égale à zéro ou alors que l ordonnée est supérieur à la hauteur de la tablette ce qui serait le cas en découpant en (3,3) sur la figure 8. Finalement, il faut être sûr de ne pas découper une zone en «escalier» puisque l on peut découper uniquement des rectangles pleins. Par exemple dans la figure 8 découper en (2,2) est impossible. Ainsi pour savoir si le coup est possible il faut vérifier pour chaque hauteur suivante si elle n est pas à la fois : plus petite que le nombre de carré à l endroit de la découpe la hauteur soit supérieure à (l ordonnée 1) Grâce à ces deux conditions on s assure qu il n y a pas une hauteur intermédiaire. Il est possible de découper en position (2,2) une tablette composée des hauteurs [3, 3, 3] ou encore [3, 3, 1] mais comme le montre la figure 8, surune[3, 3, 2] c est impossible. Figure 8 Exemplededécoupageinterdit Ainsi en cumulant tous ces tests, il est possible de savoir si un coup (défini par les coordonnées de son carré inférieur gauche) est possible. Une fois cela défini, il est maintenant question de créer l arbre de jeu qui déterminera les coups de l intelligence artificielle Première version Lors de notre réflexion concernant l arbre de jeu nous sommes arrivés à la conclusion que l IA est gagnante si elle trouve un coup pour qu ensuite le joueur ne puisse jamais arriver à la victoire. 8

10 Ainsi lorsque c est au tour de l ordinateur de jouer il suffit de trouver un seul coup gagnant pour que l on arrête de chercher (il suffit de sauvegarder le coup àjouer)etlorsquec estaujoueurdejouerilfautvérifierquetoutsespossibles coups mènent à la victoire de l IA. Il faut donc faire remonter l information dans l arbre afin que l ordinateur ne joue pas le coup qui y mène. Afin de mieux comprendre, nous allons montrer le raisonnement de l ordinateur lorsque celui-ci commence à jouer sur une tablette de largeur et de hauteur 2dans(figure 9). Figure 9 Schéma algorithmique IA Les carrés en bleu clairs signifient que c est à l IA de jouer, en rouge au joueur et les carrés noirs représentent la défaite (celui qui doit jouer au moment du carré noir a perdu). Afin de trouver un coup gagnant, l ordinateur analyse chaque coup possible à partir de la tablette d origine jusqu à trouver un coup gagnant. Pour cela il teste chaque couple de coordonnées possible (grâce à l algorithme du coup possible). S il n en trouve pas alors, il jouera le coup le plus petit possible afin d allonger le temps de jeu et espérer que le joueur parte dans une branche qui le menera àladéfaite. Dans la figure 9 l ordinateur commence par couper les deux carrés du haut, cela donne ce qui se trouve dans l éclipse rouge. C est alors au joueur de jouer et on s aperçoit qu en découpant une seule case cela va mener à la défaite de l ordinateur. Dans ce cas, la situation dans l éclipse rouge est perdante. L ordinateur va faire remonter l information "perdant" jusqu à l origine du coup qui y mène, ou à la tablette de départ et analyser un autre coup (ici découper les deux carrés de droite, l éclipse orange). Malheureusement on va observer le même résultat. La noeud de départ contiendra un vecteur de noeuds possibles et chacun de ses noeuds contiendra sa valeur (perdant ou gagnant pour l IA). 9

11 Puis l algorithme va analyser un autre coup, celui de découper le carré en haut à droite en (2,2). Le joueur se trouvera alors dans la position de l éclipse bleu claire. â ce moment là, il peut jouer deux coups. Il faut s assurer que les deux sont gagnants pour l IA puisqu un seul suffirait pour que le joueur le fasse perdre. On trouve alors que dans tous les cas le joueur perdra s il se trouve dans la position de l éclipse bleu claire. Ainsi l IA va faire monter l information «victoire»aunoeuddedépart.celui-civadoncenregistrerleprochaincoupà jouer (pointeur sur le noeud de l éclipse bleue clair). Ce processus va s appliquer pour chaque noeud, ainsi chaque noeud qui dervra être joué par l ordinateur aura en mémoire le prochain coup à jouer. Le nombre de noeuds (état de tablette) calculé dépend de l ordre d analyse des coups fils (ici en commençant par l éclipse bleu claire il n y aurait pas besoin d analyser les éclipses rouge et orange). Par ailleurs si l ordinateur se trouve en position perdante (impossibilité de gagner), il va devoir vérifier tous les cas possibles pour s assurer qu il ne peut pas gagner Analyse Nous avons implanté cette technique et elle fonctionne. Cependant nous nous sommes rendus compte d un problème majeur, le même noeud est présent un grand nombre de fois. Par exemple dans la figure 3 on s aperçoit que l éclipse rouge est la même que celle verte et de même pour l orange et la bleue. Ainsi pour des tablettes plus grandes le nombre de noeuds augmente très rapidement au point que nous n avons jamais réussi à créer une tablette 5 5. Le temps de calcul était beaucoup trop long (nous détaillerons le nombre de noeuds calculés ainsi que le temps mis par l ordinateur pour trouver la solution dans le 3.3) nous avons donc décidé d exploiter une autre méthode de calcul pour l intelligence artificielle. 3.2 Modélisation 2 Afin d optimiser la taille maximum de la tablette, nous avons pensé à une deuxième structure qui permettrait de ne pas dupliquer les noeuds (positions de la tablette) de l arbre. Avec cette contrainte les noeuds ne devaient plus porter d étiquette " Joueur " ou " IA " qui serait alors déterminée par l ordre de jeu. 10

12 Figure 10 Schéma de l arbre de jeu Pour ce faire nous avons décidé d ajouter une classe Arbre qui contiendrait tous les noeuds possibles dans un tableau où chaque noeud pointerait sur ceux qui sont accessibles depuis ce dernier. Une difficulté a été de trouver un algorithme qui prendrait deux noeuds en paramètre et retournerait vrai si le deuxième est accessible depuis le premier (deuxième est fils du premier) Construction de l arbre Un arbre contenant l intégralité des positions de la tablette dans un tableau doit en premier lieu instancier toutes ces positions. Pour une tablette de hauteur hetdelargeurl(enincluantlatablettevide)lenombredenoeudsestégalà: nbn = hx hx hx... 1 x 1=0 x 2=x 1 x l =x l 1 N ayant pu trouver d algorithme récursif qui crée tous ces noeuds avec une taille de tablette donnée, nous avons, après plusieurs essais, déterminé qu avec notre technique la taille maximum raisonnable d une tablette serait limitée à 9*9 (une tablette 9*9 prenant environ 1 minute à être construite). Le constructeur de l arbre contient par conséquent 9 boucles imbriquées pour construire la totalité des noeuds (voir constructeur de la classe Arbre en annexe). Dans le cas où l on souhaite augmenter la taille maximum de la tablette, il faudra se replonger dans le code. 11

13 Par exemple pour une tablette 3*3 les noeuds crées dans l ordre sont : NULL Une fois la totalité des noeuds crée, on doit les relier. Pour ce faire, pour chaque noeud crée on teste si les noeuds présents avant dans le tableau (par construction les noeuds suivants ne peuvent être obtenus car ils sont "supérieurs" dans la hiérarchie des coups) sont des coups jouables grâce à une méthode de la classe Noeud qui prend un Noeud en paramètre. La complexité amortie de push_back étant constante (au pire des cas (n) avec nnombred élémentsduvecteur)lacréationd unnoeudsefaitenconstant. Celle de couppossible est en (l) dans le pire des cas (voir paragraphe suivant). L algorithme de création de l arbre a donc une complexité de : nbn X 1 (nbn + i l) = (nbn + i= Coups possibles l nbn(nbn 1) )= (l nbn 2 ) 2 Une grande difficulté a été de savoir si un coup était possible depuis un autre en comparant les vecteurs des deux tablettes. Nous avons opté pour un algorithme qui procéderait par élimination en distinguant les différents cas : si on a à faire au même noeud alors faux si la tablette passée en paramètre est plus haute (test sur la 1e colonne) ou plus large alors faux si la tablette passée en paramètre est de largeur inférieure alors : si on a découpé une ou plusieurs lignes et colonnes entières en même temps (3.3.3! 2.2) alors faux. si la tablette est en escalier et on découpe plus que la marche inférieure (3.2.1! 3) alors faux. si on a découpé une ou plusieurs colonnes entières et qu on essaye de découper sur une ligne (3.3.3! 3.2) alors faux. 12

14 si les tablettes sont de même largeur alors : s il y a un escalier sur la tablette et qu on essaie de l égaliser (3.2.1! 1.1.1) alors faux. si on essaye de découper en escalier (3.3.3! 3.2.1) alors faux. si la tablette passée en paramètre est nulle et il y a un escalier sur la tablette initiale (2.1! NULL) alors faux. Si aucune des ces conditions n est respectée c est que le coup peut être joué par conséquent vrai. Voir la méthode Noeud : :couppossible(noeud* n) en annexe. Une fois l arbre créé et les noeuds reliés, pour que le joueur puisse jouer nous avons mis en place une méthode Noeud : :getprochainnoeud(int x, int y) (voir annexe) qui prend en paramètre les coordonnées entrées par le joueur et retourne l adresse du noeud correspondant au noeud obtenu après découpe. Si ce noeud n existe pas elle renvoie NULL. Pour cela la fonction crée une copie de la tablette actuelle (l),faitundécoupage sans se soucier des escaliers et règles de découpage et vérifie si le vecteur ainsi obtenu est présent dans la liste des coups possibles. D ou pour cette méthode la complexité est de : (nbcoups l + l) = (l nbcoups) Evaluation des noeuds et parcours de l arbre A chaque noeud on a également ajouté deux booléens (visited et win) qui permettraient d évaluer si un noeud a été visité lors de l exploration de l arbre et s il a été déclaré gagnant. Un noeud est perdant s il n a que des noeuds gagnants en successeur. Par défaut le seul noeud visité et déclaré gagnant est le noeud NULL qui est la seule feuille de l arbre (s il n y a plus de coups à jouer c est que le joueur précédent a mangé le carré empoisonné). Mise en place du NegMax : En premier lieu nous avons mis en place le Minimax qui prenait le joueur en paramètre et explorait chaque sous arbre à chaque fois jusqu à la feuille. Celui-ci mettait beaucoup trop de temps pour explorer l arbre à partir d une tablette 5*5 (Voir Noeud : :minimax(bool j) en annexe). Nous l avons ensuite simplifié en negmax, introduit les booléens visited et win et mis en place le pruning (un noeud est gagnant s il a au moins un perdant en successeur) au niveau de celui-ci ce qui a donné l algorithme suivant : 13

15 Algorithm 1 NegMax Ensure: booléen égal à true si un noeud est gagnant if le noeud est visité then return gain else evalue true for chaque fils p du noeud do if non(p! negmax() then gain true return true end if end for gain false return gain end if Exemple avec une tablette 2*2 : Le premier coup joué sera donc le coup (2.1) car il met le joueur en position perdante. Figure 11 Le Negmax appliqué à l arbre de jeu La complexité maximale du NegMax ainsi obtenu lors de sa première exécution est en (nbn) car il passera au plus une fois par chaque noeud de l arbre. Pour les appels suivants, le gain de la majorité (ou totalité) des noeuds étant fixé par la première exécution il ne visitera que les noeuds non évalués ou sera constant. Comme nous pouvons le constater nous avons grandement augmenté la taille de la tablette grâce cette nouvelle modélisation. Voyons maintenant nos gains au niveau des performances en confrontant les deux techniques. 14

16 3.3 Confrontation des deux structures Suite à l élaboration de deux modélisations différentes nous avons souhaité mettre en évidence les différences de performances lors de l exécution des deux programmes. Pour cela nous avons effectué une série de tests sur le nombre de nœuds crées et le temps de création de l arbre incluant la recherche du chemin gagnant en fonction de la taille de la tablette. Les tests ont été effectués sur un MacBookAir 2011 avec un processeur Intel Core i5 cadencé à 1.7GHz, possédant 4Go de RAM sous OSX (Mavericks). Pour le calcul du temps nous avons effectué une moyenne sur 10 exécutions. Voici les résultats obtenus : Sur le nombre de noeuds : Figure 12 Histogramme comparatif du nombre de noeuds Figure 13 Tableau comparatif du nombre de noeuds 15

17 Sur le temps de création incluant le calcul du chemin gagnant : Figure 14 Histogramme comparatif de la rapidité de construction Figure 15 Tableau comparatif de la rapidité de construction On peut clairement observer que le nombre de nœuds de la modélisation 1 augmente d une façon exponentielle très rapidement tandis que la modélisation 2metplusdetempsàtendreversl infini.etantdonnéqueletempsdecréation de l arbre est lié au nombre de nœuds, il suit le même schéma. Grâce à ces comparaisons il est clair que la deuxième méthode est techniquement plus efficace. Avantages Inconvénients Modélisation 1 +Constructeur récursif -Petite taille de tablette -Noeuds dupliqués un grand nombre de fois Modélisation 2 +Taille de tablette supérieure -Constructeur non récursif +Noeuds non dupliqués +Navigation facile dans l arbre 16

18 4 Liaison avec l interface graphique S étant fixé l objectif de réaliser le jeu de la tablette de chocolat en utilisant une interface graphique nous avons opté pour une interface utilisant la SFML qui serait générique (qui pourrait être réutilisée pour l implémentation d un autre jeu). Nous vous avons fourni un diagramme UML (orienté C++) en annexe, voici son explication : Le diagramme se décompose en trois parties importantes : La première est la classe Game qui est le gestionnaire de jeu. C est elle qui contient la fenêtre de rendu ainsi que la variable des événements. Elle contient également un pointeur sur chaque phase de jeu (intro, menu, partie, etc..) afin de pouvoir communiquer avec ces dernières. La deuxième est la classe Phase qui est une classe abstraite. Chaque phase est composée d images, de textes, de musiques, de sons, de boutons et de slide-bars qui lui sont propres classés dans des tables de hachage. Elle contient également un pointeur sur la fenêtre de rendu du jeu ainsi que ses événements et un pointeur sur le gestionnaire de jeu Game afin de pouvoir communiquer avec lui et les autres phases. La troisième est la classe Arbre qui contient tous les algorithmes du jeu et qui est instanciée dans une partie. Au lancement du jeu, la classe Game est instanciée, cette dernière instancie les phases Intro et Menu, puis Menu instancie les phases MenuOptions et MenuBonus. Ensuite l intro se lance. Lorsque le joueur clique sur «Jouer» la classe Partie est instanciée et cette dernière instancie le PartMenu (le menu de pause). La partie se déroule en plusieurs étapes. D abord on propose au joueur de rentrer son nom, les dimensions de la tablette ainsi que le joueur qui commence. Une fois les dimensions choisies et non nulles le joueur valide. On instancie alors l Arbre de jeu et la partie se lance. Afin de ne pas modifier le code déjà écrit pour l Arbre et les Noeuds, nous avons repris le système de coordonnées pour la gestion de la tablette et avons décidé de faire tourner l affichage et l arbre en parallèle. Le carré empoisonné est affiché en premier puis les autres carrés de la tablette sont placés relativement par rapport à celui-ci. Lorsque c est à l IA de jouer on trouve le coup suivant au moyen du NegMax et la position actuelle dans l arbre est modifiée, l affichage est ainsi mis à jour. Lorsque c est au joueur de jouer, les coordonnées de la souris dans la tablette, par référence au carré empoisonné, nous donnent les coordonnées du carré de chocolat à manger et sont transmises à l arbre. Alors la tablette initiale est découpée selon ce carré et un nouveau vecteur contenant la pseudo-nouvelle tablette est crée. Ensuite on compare avec la liste des coups successeurs de la tablette initiale, si ce coup existe alors son adresse est renvoyée et la position actuelle change sinon on renvoie NULL et le joueur ne peut jouer le carré sur lequel se situe la souris, et ainsi de suite.. Lorsque la position 17

19 actuelle devient le vecteur NULL la partie s arrête et on passe à l étape de fin de partie qui annonce le gagnant et propose de quitter ou recommencer. Si le joueur quitte, l arbre est détruit et on revient au menu principal. La liaison avec l interface graphique n a donc pas nécessité de nouveau algorithmes et reprend le même fonctionnement qu une exécution sous terminal sauf qu au lieu du main c est la phase Part qui gère l arbre de jeu et qui contient les variables nécessaires au déroulement d une partie. 5 Conclusion Grâce à la réalisation de ce projet, nous avons appris de nombreuses choses. En premier lieu, le travail en groupe que nous avons dû déployer nous a appris à organiser un projet d une telle envergure. Grâce à ce travail, on a pu constater à quoi pourrait ressembler un travail professionnel. Par conséquent cela a amélioré notre communication et organisation au sein du groupe. D un point de vue technique, ce projet nous a permi d améliorer grandement notre connaissance du C++, en particulier de la construction des arbres et de maîtrise des classes. Un point important est que nous avons appris à ne pas rester devant un échec (tablette en 5*5 impossible à compiler) et savoir rebondir afin d améliorer grandement notre programme (élaboration d une seconde intelligence artificielle). Néanmoins de nombreux points pourraient être améliorés comme des bonus graphiques (ajout d options tel que le passage en chocolat blanc, avec ou sans noisettes, etc..), le changement de plate-forme pour le jeu (tablette, mobile) ou l ajout des bibliothèques statiques SFML afin d y jouer avec un simple exécutable. Nous pourrions également ajouter des niveaux de difficulté, avec pour idée que l ordinateur joue des coups qui augmentent les possibilités de gain du joueur. Par exemple, pour un niveau facile, l ordinateur empruntera une branche où le nombre de chemins gagnants pour le joueur est bien supérieur aux siens. Pour le niveau difficile, l ordinateur pourrait trouver le chemin qui comporte le moins de possibilités de gain pour le joueur (mais en laissant au moins un) et enfin le niveau imbattable tel que celui que nous avons créé. Finalement, il pourrait être intéressant de changer les règles afin d augmenter le nombre de coups jouables (comme l exemple dans la feuille du projet) même si après y avoir réfléchi, cela nous semble très compliqué à mettre en œuvre afin de diversifier les stratégies gagnantes. Nous voudrions remercier chaleureusement Hervé Dicky pour son soutien et son aide dans la réalisation de ce projet et espérons que vous prendrez autant plaisir à jouer à ce jeu que nous avons pris à le développer. 18

20 Annexe au projet du carré empoisonné Iaroslav AMPLEEV, Nicolas POMPIDOR, Antoine LAURENT, Sacha WEILL. Table des matières 1. Règles initiales Coup possible 1 (Modélisation 1) Constructeur de l'arbre (Modélisation 2) Constructeur des nœud (Modélisation 2) Méthode getprochainnoeud (Modélisation 2) Coup possible (Modélisation 2) MiniMax NegMax Diagramme UML /8

21 1. Règles initiales 2/8

22 2. Coup possible 1 (Modélisation 1) bool Noeud::CoupPossible(int absc, int ordo) { absc+=1; ordo+=1; int compteur=0; if(absc>0 && ordo>0) { if(absc<=largeur && ordo<=hauteur && tablette[absc-1]!=0) { //je vérifie que les coordonnées existent et que l'on ne découpe pas dans le vide for(int i=absc-1;i<largeur;i++) { if(tablette[i]<tablette[absc-1] and tablette[i]!=0 and tablette[i]>ordo-1) return 0; return 1; 3/8

23 3. Constructeur de l'arbre (Modélisation 2) Arbre::Arbre(int largeur, int hauteur, bool j):largeur(largeur), hauteur(hauteur), joueur(j){ // on crée tous les états possibles pour une tablette fixée en les ajoutant à noeuds for (int i = 0; i <= hauteur; i++) { if (largeur == 1) { noeuds.push_back(new Noeud(this, i)) ; else if (largeur < 1) break; for (int j = i; j <= hauteur; j++) { if (largeur == 2) { noeuds.push_back(new Noeud(this, j, i)); else if (largeur < 2) break; for (int k = j; k <= hauteur; k++) { if (largeur == 3) { noeuds.push_back(new Noeud(this, k, j, i)); else if (largeur < 3) break; for (int l = k; l <= hauteur; l++) { if (largeur == 4) { noeuds.push_back(new Noeud(this, l, k, j, i)); else if (largeur < 4) break; for (int m = l; m <= hauteur; m++) { if (largeur == 5) { noeuds.push_back(new Noeud(this, m, l, k, j, i)); else if (largeur < 5) break; for (int n = m; n <= hauteur; n++) { if (largeur == 6) { noeuds.push_back(new Noeud(this, n, m, l, k, j, i)); else if (largeur < 6) break; for (int o = n; o <= hauteur; o++) { if (largeur == 7) { noeuds.push_back(new Noeud(this, o, n, m, l, k, j, i)); else if (largeur < 7) break; for (int p = o; p <= hauteur; p++) { if (largeur == 8) { noeuds.push_back(new Noeud(this, p, o, n, m, l, k, j, i)); else if (largeur < 8) break; for (int q = p; q <= hauteur; q++) { if (largeur == 9) { noeuds.push_back(new Noeud(this, q, p, o, n, m, l, k, j, i)); else if (largeur < 9) break; racine = noeuds[noeuds.size()-1]; // la racine (tablette initiale est le dernier noeud crée posactuelle = racine; // on commencera à jouer à partir de la racine if (noeuds.size()) { noeuds[0]->setevaluated(1); noeuds[0]->setwin(1); noeuds[1]->setevaluated(1); noeuds[1]->setwin(0); // on fait la liaison entre les noeuds for (int i = 1; i < noeuds.size(); i++) { // on commence à 1 car le 1e est le nul et n'aura pas de successeur for (int ii = 0; ii <= i; ii++) { if (noeuds[i]->couppossible(noeuds[ii])) { // si le coup est possible on l'ajoute noeuds[i]->getcoups()->push_back(noeuds[ii]); 4/8

24 4. Constructeur des nœud (Modélisation 2) Noeud::Noeud(Arbre* a, int q, int p, int o, int n, int m, int l, int k, int j, int i) : ARBRE_DE_JEU(a), tablette(0), coups(0), evaluated(0), win(0) { if (q) { tablette.push_back(q); if (p) { tablette.push_back(p); if (o) { tablette.push_back(o); if (n) { tablette.push_back(n); if (m) { tablette.push_back(m); if (l) { tablette.push_back(l); if (k) { tablette.push_back(k); if (j) { tablette.push_back(j); if (i) { tablette.push_back(i); 5. Méthode getprochainnoeud (Modélisation 2) Noeud* Noeud::getProchainNoeud(int x, int y) const{ // méthode pour le joueur if (x == 0 y == 0) { return NULL; vector<unsigned char> tmp(tablette); // on copie un vector de la tablette initiale for (int i = x - 1; i < tmp.size(); i++) { if (tmp[i] >= y){ // on découpe selon un découpage simple tmp[i] = y - 1; for (int i = tmp.size() - 1; i >= 0; i--) { if (tmp[i] == 0) { tmp.pop_back(); // on enleve les 0 inutiles for (int i = 0; i < coups.size(); i++) { // on compare avec les coups possibles if (tmp.size()!= coups[i]->tablette.size()) { continue; bool ok = true; for (int j = 0; j < tmp.size(); j++) { ok = (tmp[j] == coups[i]->tablette[j]); if (!ok) break; if (ok) { return coups[i]; // si le coup existe on renvoie son adresse return NULL; // sinon renvoie NULL 5/8

25 6. Coup possible (Modélisation 2) bool Noeud::coupPossible(Noeud* n) const{ if (this == n) { //si meme noeud alors faux return false; if (n->tablette.size()) { if (n->tablette.size() > tablette.size()) { // si tab +large alors faux return false; for (int i = 0; i < n->tablette.size(); i++) { // si tab +haute alors faux if (n->tablette[i] > tablette[i]) { return false; if (n->tablette.size() < tablette.size()) { // si largeur inférieure if (n->tablette[0] < tablette[0]) { // si on a decoupé une ou ++ colonne entiere et qu'on essaye en meme temps de decouper une ou ++ ligne entiere alors faux return false; for (int i = tablette.size() - 1; i > 0; i--) { if (tablette[i] < tablette[i-1]) { if (n->tablette.size() < i) { // si la tablette est en escalier et on découpe plus que la marche inférieure alors faux return false; break; for (int i = 0; i < n->tablette.size(); i++) { // si on a decoupé une ou ++ colonne entiere et qu'on essaye en meme temps de decouper une ligne alors faux if (n->tablette[i] < tablette[i]) { return false; else { // si meme largeur de tablette int positiondecoupe = 0; int diff = 0; for (int i = 0; i < tablette.size(); i++) { if (!diff && n->tablette[i] < tablette[i]) { // si on trouve une difference diff = tablette[i] - n->tablette[i]; positiondecoupe = i; // on retient l'indice de la difference else { if (diff) { if (diff!= tablette[i] - n->tablette[i] && tablette[i] - n- >tablette[i]) { return false; // si il y a un escalier et qu'on essaye de l'égaliser alors faux if (n->tablette[i] == n->tablette[positiondecoupe]) { continue; // si on a la meme hauteur on continue le for else { if (n->tablette[i] < tablette[i]) { return false; // sinon on ne peut découper en escalier else { // si n vide if (tablette.size() > 1) { if (vectorescalier(tablette)) { // si escalier sur la tablette alors faux return false; return true; 6/8

26 7. MiniMax bool Noeud::minimax(bool j){ // appeler avec 1 sur les succ pour l'ia infodebug if (!coups.size()) { return!j; else { bool mini = true, maxi = false; for (int i = 0; i < coups.size(); i++) { if (j) { mini = coups[i]->minimax(!j); if (!mini) break; else { maxi = coups[i]->minimax(!j); if (maxi) break; if (j) return mini; else return maxi; 8. NegMax bool Noeud::negmax(){ // appeler!negmax() sur les succ pour l'ia if (evaluated) { return win; else { evaluated = 1; for (int i = 0; i < coups.size(); i++) { if (!coups[i]->negmax()) { win = 1; // Gagnant->au moins 1 perdant en succ return 1; win = 0; // Perdant->tout succ est gagnant return 0; 9. Diagramme UML 7/8

27 8/8