Vous êtes sur la page 1sur 51

2008/ 2009

Projet logiciel L3 : Jeu du morpion

Alexandre THIL http://alexandre.thil.info L3 Mathmatiques & Informatique

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

I.

Prsentation du projet .......................................................................................................... 3 1. Objectif ........................................................................................................................................ 3 2. Rcapitulatif du projet termin ................................................................................................... 4 3. Rgles du jeu ............................................................................................................................... 5 4. Installation et lancement............................................................................................................. 6 Prsentation fonctionnelle .................................................................................................... 7 1. Nouvelle partie (Paramtres) ...................................................................................................... 7 2. Le menu ....................................................................................................................................... 8 3. Les rgles du jeu .......................................................................................................................... 9 4. Le jeu ......................................................................................................................................... 10 5. Stratgies ................................................................................................................................... 11

I.

III. Prsentation technique ....................................................................................................... 12 1. Architecture technique.............................................................................................................. 12 2. Diagramme de classes ............................................................................................................... 13 3. Les fichiers du projet ................................................................................................................. 16 4. Le Pattern Singleton ............................................................................................................ 17 5. Le droulement du jeu .............................................................................................................. 18 6. Le systme graphique................................................................................................................ 22 7. La sauvegarde ............................................................................................................................ 25 8. Les exceptions ............................................................................................................................... 28 9. Les mdias ..................................................................................................................................... 29 10. Le systme audio ......................................................................................................................... 30 11. Les Replays ............................................................................................................................ 31 12. Le systme multi-langages .......................................................................................................... 33 12. Limpression de grilles de morpion (PDF).................................................................................... 35 13. Documentation JavaDoc ........................................................................................................ 35 IV. LIntelligence Artificielle (IA)................................................................................................ 36 1. Prsentation .............................................................................................................................. 36 2. Complexit du Morpion ............................................................................................................ 37 3. Lalgorithme Expert / Bas sur les rgles ............................................................................ 38 4. La fonction dvaluation ............................................................................................................ 39 5. Lalgorithme Min-Max ......................................................................................................... 40 6. Llagage Alpha-Bta ........................................................................................................... 43 7. La convention NegaMax ...................................................................................................... 44 8. LIA Alatoire ....................................................................................................................... 44 9. Implmentation ......................................................................................................................... 45 V. Conclusion .......................................................................................................................... 47 VI. Annexes.............................................................................................................................. 48 1. Linterface de dveloppement (IDE) utilise : Eclipse ............................................................... 48 2. Le logiciel utilis pour les diagrammes : ArgoUML ................................................................... 49 3. Exemple de grille de Morpion imprime via le logiciel (10x10) ................................................ 50 4. Exemple de jeu complexe.......................................................................................................... 51

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

I.

Prsentation du projet

1. Objectif
Le but du projet est de programmer un simulateur du jeu Morpion ( Tic Tac Toe en anglais) avec interface graphique, en utilisant le langage de programmation Java. La taille de la grille doit tre paramtrable par lutilisateur (de 3x3 26x26), le nombre de symboles (de la taille minimale de la grille, 26), ainsi que le nombre de joueurs de 2 26. Lorsquune partie est finie, il doit tre possible den relancer une nouvelle sans devoir redmarrer lapplication, et galement de pouvoir modifier les paramtres entre chaque partie. Chaque joueur est soit contrl par humain, soit par lordinateur (Intelligence artificielle), et possde un symbole (O ou X pour le mode 2 joueurs, sinon une lettre de lalphabet). Il doit galement tre possible de sauvegarder ltat dune partie et den reprendre le fonctionnement tout moment, mme aprs la fermeture de lapplication, dannuler un ou plusieurs coups pendant une partie, et galement de revoir le droulement dune partie une fois celle-ci finie ( Replay ).

Le morpion

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

2. Rcapitulatif du projet termin


Partie fonctionnelle : Morpion paramtrable (taille de la grille, nombre de symboles, nombre de joueurs) Joueurs paramtrables (nom, type : humain / ordinateur, difficult de lIA, symbole) Les paramtres sont conservs entre chaque partie Possibilit de sauvegarder la partie (format XML) Possibilit de voir le Replay dune partie Possibilit dannuler un ou plusieurs coups Plusieurs IA (Intelligences Artificielles) Systme audio Gestion des scores

Partie technique : Version graphique Sparation des couches ( Vue / Evnements et Traitements / Donnes Utilisation du patron de conception Singleton Gestion des erreurs Evolutif (Langues, IA, Fonctionnalits)

Fonctionnalits supplmentaires : Archive Jar excutable Multilingue Possibilit dimprimer des feuilles de morpion (vierges) Documentation dveloppeur gnre (JavaDoc)

Configuration : Les paramtres gnraux (ex : nombre maximum de lignes, taille de lcran) sont stocks statiquement dans la classe model.Game .

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

3. Rgles du jeu
Lors du rglage des paramtres, il faut choisir : La taille de la grille Le nombre de symboles aligner Le nombre de joueurs Les symboles utiliss par les joueurs Les joueurs qui seront contrls par lordinateur (Intelligence artificielle) Lorsque la partie commence, un joueur est slectionn au hasard, lordre de jeu normal est ensuite respect. La partie est termine soit lorsquil ya un match nul, ou lorsque un vainqueur t dsign. Le jeu se joue au tour par tour , chaque joueur doit, lun aprs lautre, placer son symbole dans une case libre dans la grille. Si un joueur parvient aligner suffisamment de symboles, celui-ci est dsign vainqueur, et le tableau des scores est ensuite affich. Celui-ci peut tre conserv en effectuant une sauvegarde.

Victoire de O

Match nul

Victoire de C

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

4. Installation et lancement
a. Pr-requis Le logiciel fonctionne uniquement en mode graphique, et ncessite au minimum la version 6 de Java (JRE), ainsi que le Kit de dveloppement (JDK) dans la version 1.6.0_14 au minimum. Tlchargements disponibles gratuitement sur : http://www.java.com

b. Lancement

Le programme t empaquet sous la forme dune archive JAR excutable, et il ya plusieurs solutions pour excuter le jeu. Double-cliquer sur Morpion.jar Avec la ligne de commande : java jar Morpion.jar Avec la ligne de commande : java jar Morpion.jar EN (jeu en anglais)

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

I.

Prsentation fonctionnelle

1. Nouvelle partie (Paramtres)


Cette page est affiche lors du lancement de lapplication, et la fin de chaque partie (on peut redfinir les paramtres chaque fois). On peut rgler les paramtres de grille : Le nombre de lignes Le nombre de colonnes Le nombre de symboles aligner pour gagner Le nombre de joueurs

Ainsi que les paramtres de chaque joueur : Le nom Le type (humain, ordinateur) La difficult (si ordinateur : trs facile, facile, moyen, difficile, expert) Le symbole utilis (si 2 joueurs : O ou X, sinon : les lettres de lalphabet A-Z)

On lance la partie on cliquant sur le bouton Lancer la partie .

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

2. Le menu
Le menu du jeu est dcompos de cette faon. Des touches de raccourci sont assignes chaque item. Partie Nouvelle partie Charger Sauvegarder Annuler le coup Quitter ? Afficher laide ( F1 ) A propos de Morpion ( F2 ) ( Ctrl + N) ( Ctrl + L) ( Ctrl +S ) (Ctrl + Z) (Ctrl + Q)

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

3. Les rgles du jeu


Pour consulter les rgles pendant le jeu, il faut cliquer sur ( Menu > ? > Afficher laide ), ou utiliser le traditionnel bouton F1. Le texte est stock au format HTML dans le rpertoire des mdias (un fichier par langue, ex : /medias/rules-fr.txt). Pour laffichage, on charge le contenu du fichier dans un JLabel . Le format HTML est gr nativement par ce composant.

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

4. Le jeu
Les joueurs jouent lun aprs lautre et plaant leur symbole dans une case libre. Au dbut de la partie, un joueur est slectionn alatoirement, lordre tabli au dpart est ensuite respect. Si un joueur humain clique sur une case alors quil nest pas autoris jouer (par exemple : cest lordinateur de jouer, ou la case est dj prise), le clic sera sans effet. Pour ajouter un semblant de ralisme au jeu, lorsque cest le tour dun ordinateur de jouer, un temps variable (court) scoule avant quil joue. Si un alignement gagnant (par exemple 3 ronds ou croix pour la version classique) est dtect, le joueur remporte la partie et gagne un point. A la fin de la partie, le tableau des scores est affich, lutilisateur peut ensuite : Lancer une nouvelle partie (en modifiant ou non les paramtres) Annuler un ou plusieurs coups et rejouer la partie courante Voir le Replay de la partie

Exemple de partie gagnante pour les ronds

10

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

5. Stratgies
Peu importe la version utilise, lattitude adopter est de toujours chercher aligner le maximum de symboles (attaque), et empcher le ou les adversaires den faire autant (dfense). Dans le cas de la version classique (3x3) le joueur qui dbute la partie dispose dun avantage non ngligeable car il peut raliser 8 alignements diffrents. Cependant, un joueur aguerri, ou lordinateur en difficult maximale puisquil est capable danalyser toutes les possibilits de jeu, est capable de ne jamais perdre. Deux intelligences artificielles de niveau identiques, ainsi que deux joueurs jouant strictement de la mme faon ne feront que des matches nuls !

Voici quelques rgles si les joueurs jouent de faon optimale : O : joueur X : adversaire 1. Si O joue au centre, il ne peut pas perdre 2. Si ensuite, X joue dans la croix, il perd 3. Si X joue dans une diagonale, il faut le bloquer (jouer dans la mme diagonale).

11

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

III.

Prsentation technique

1. Architecture technique
Les couches de lapplication sont spares. 1. La fonction dentre La fonction principale prend en compte les arguments passs au programme, cre linstance du jeu et lance le rendu graphique. 2. La partie Mtier (Package : model) Toutes les donnes et traitement spcifiques (ex : jouer un coup, lancer lIA, vrifie si un joueur est gagnant) sont regroupes dans ce package. Les classes prsentes ici ne soccupent pas de la partie graphique et se content deffectuer des traitements et de renvoyer des messages. 3. La partie Graphique (package : gui) Cette partie gre laffiche et les actions de lutilisateur (clics, saisies au clavier). La partie graphique (Vue) et contrleur sont mlangs car la complexit du projet ne justifie pas la mise en place dune solution MVC stricte qui est plutt rserves aux projets trs complexes qui contiennent des centaines de vues (crans).

Lavantage de cette solution est de simplifier la maintenance du projet : La partie Traitement des donnes et Affichage sont spares, ce qui rend le code plus comprhensible par une personne externe au projet. Par exemple, il serait possible de reprogrammer rapidement le logiciel pour en faire une version Mode console ou JSP en ne modifiant que les classes de la partie Gui , il serait possible de rutiliser toutes les classes du package Model sans modifications. La partie la plus importante est la classe model.Game . Cest elle qui gre toutes les donnes et qui fournit les mthodes adaptes la partie graphique. Par exemple, lors du clic sur une case, linterface graphique appelle le modle et appelle la fonction correspondante dans le modle, qui sassurera que le coup est lgal (possible) puis mettra jour les donnes. Linterface graphique devra ensuite rafrachir laffichage pour que les modifications soient perceptibles par lutilisateur. Puisque le jeu est en mode Tour par tour et non Temps rel , on peut simplement mettre jour laffichage aprs chaque action.

12

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

2. Diagramme de classes

Relations entre classes et packages

Trait plein : Hritage Trait en pointills : Relation dutilisation

13

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

Package : Model

14

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

Package : Gui

15

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

3. Les fichiers du projet


/ Morpion.java Package principal Point dentre du programme

/gui/ Window.java Game.java GameScores.java Help.java Menu.java Settings.java Sound.java

Package : Interface graphique Fentre principale Panneau : Partie en cours Pop-up des scores Pop-up (rgles du jeu) Menu Panneau : Nouvelle partie (paramtres du jeu) Lecture de sons

/model/ Case.java Game.java Player.java /model/ai/ AI.java ClassicAI.java MinMax.java Random.java /model/datas/ Datas.java PDF.java XML.java /model/lang/ I18n.java FR.java EN.java

Package : Modle Case Systme de jeu Joueur Package : Intelligence artificielle Intelligence artificielle (classe principale) Intelligence artificielle spcialise cas classique (3x3, 2J) Algorithme Min-Max Algorithme alatoire Package : Objets spciaux Non utilis Impression de feuilles (grilles de jeu) Gestion de la sauvegarde Package : Fichiers de langue Gestion des langues Langue : Franais Langue : Anglais

/medias/ clic1.wav clic2.wav draw.java victory.wav human.jpg computer.png ico.jpg rules-fr.txt rules-en.txt

Mdias Son n1 jou lors dun clic Son n2 jou lors dun clic Son jou lors dun match nul Son jou lors dune victoire Image : Joueur humain Image : Joueur ordinateur Icne de lapplication Rgles du jeu : Franais (HTML) Rgles du jeu : Anglais (HTML)

16

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

4. Le Pattern Singleton
Le problme : plusieurs objets (ex : le systme de jeu, la fentre principale) doivent pouvoir tre accessibles depuis nimporte classe du code, cela implique de transmettre chaque instance une rfrence. Ceci est bien entendu complexe raliser, et rend la maintenance plus difficile.

La solution : Le Singleton est un patron de conception ( Design Pattern ) qui facilite le dveloppement du code. Le principe est le suivant, lorsquon appelle la classe concerne, on ne linstancie pas directement mais on rcupre son instance (stocke localement et statiquement). Si celle-ci nexiste pas encore (premier appel), alors on la cre et on lenregistre dans la variable. De cette faon, lorsquon fera un appel vers linstance de lobjet Game , la rfrence sera toujours correcte : Game game = Game.getInstance() ; Le fait que la proprit instance soit statique implique quelle soit commune toutes les instances de cette classe, le Singleton se base sur cette proprit. Il est important que la mthode getInstance() possde lattribut synchronized pour assurer le fonctionnement normal de la classe dans un environnement multi-thread.

Exemple de code : public class Singleton { private static Singleton instance = null; protected Singleton() {} public synchronized static Singleton getInstance() { if (instance == null) instance = new Singleton(); return instance; } }

17

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

5. Le droulement du jeu
1. La slection dune case Les cases sont affiches sous la forme de boutons et possdent un nom sous la forme X-Y (ex : 0-0 pour la case en haut gauche, 1-2 pour la case la 1re ligne/2me colonne). Le nom est utilis par le programme pour rcuprer facilement les coordonnes de la case lors du clic.

a. Si le joueur est humain Lorsquun joueur humain slectionne une case, le programme vrifie quil est bien autoris jouer (que cest son tour), et que la case est libre. Si laction de jeu est lgale (possible) un message est envoy pour mettre jour le jeu, puis laffichage est mis jour (cf. : sparation des couches : vue/donnes). Ensuite, la procdure Test de victoire est excute pour savoir sil ya un alignement gagnant ou un match nul. Sinon, si la partie nest pas termine, on passe au joueur suivant.

b. Si le joueur est contrl par lordinateur Cette partie est dtaille dans la section Intelligence artificielle (IA). Le programme lance lIA en fonction des paramtres du joueur (il ya plusieurs niveaux, et il pourrait ventuellement yavoir plusieurs types diffrents), puis rcupre les coordonnes de la case jouer.

c. Test de victoire A chaque tour on vrifie sil ya un vainqueur, pour cela on recherche pour chaque ligne (horizontale, verticale et diagonale) sil ya au moins un alignement gagnant (un joueur peut avoir plusieurs lignes qui se rejoignent pour former un alignement plus grand, mais cela est trs rare et ne donne pas plus de points).

18

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique Les algorithmes pour les versions classiques et gnrales sont trs diffrents puisque dans la premire sil ya 3 pions aligns il ya forcment victoire, contrairement lautre version.

On note C[0][0] la case en haut gauche, et J le numro du joueur. C[i][j] = 0 Case vide C[i][j] = J Case joue par J

Algorithme pour la version classique (3x3) : Si ( C[0][0] = J ou (C[1][0] = J ou (C[2][0] = J ou (C[0][0] = J ou (C[1][0] = J ou (C[2][0] = J et et et et et et C[0][1] = J C[0][1] = J C[0][1] = J C[0][1] = J C[1][1] = J C[2][1] = J et et et et et et C[0][2] = J ) C[0][2] = J ) C[0][2] = J ) C[0][2] = J ) C[1][2] = J ) C[2][2] = J )

ou (C[0][0] = J et C[1][1] = J et C[2][2] = J ) ou (C[2][2] = J et C[1][1] = J et C[2][0] = J ) alors J gagne Sinon J ne gagne pas

Algorithme pour la version gnrale (m*n) : La mthode prcdente lavantage dtre rapidement code et trs efficace en termes de rapidit dexcution, mais est inutilisable dans le cas de la version gnrale car le nombre de conditions tester crot exponentiellement. La premire ide est de compter le nombre de symboles du joueur dans chaque ligne mais cette solution ne fonctionne pas car il peut yavoir des espaces entre les pices (contrairement la version 3x3), (ex : O O X O O, il ya 4 pions aligns, mais pas conscutivement). On va donc crire une fonction qui va, pour chaque ligne, compter le nombre de symboles qui sont aligns conscutivement. Pour cela on se place sur chaque case en bordure de la grille, et on excute une fonction paramtre (position de dpart, offset de dplacement) pour parcourir chaque ligne. Par exemple, si on se place la case [0-0] (cf. : 1A selon le sujet du projet) et quon dfinit un offset de dplacement de [1,1] (dplacement horizontal : 1, vertical : 1), le programme va tester toutes les cases sur la diagonale partant de ce point vers le 19

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique point situ en bas droite. Le repre (0,0) correspond au point en haut gauche, et on se dirige vers le point en bas droite. (ex : +1 horizontal +1 vers la droite, +1 vertical +1 vers le bas). La fonction est stoppe lorsque le programme atteint une case en dehors la grille, cela permet de grer les cases ou la grille est rectangulaire. On ne stoppe pas le processus lorsque un alignement correct est trouv, car il est possible quil yen ai plusieurs qui se rejoignent, il faut donc parcourir toutes les possibilits. Il est possible damliorer lalgorithme suivant en vitant certains tests inutiles, par exemple il est impossible dobtenir un alignement dans les coins, surtout lorsque le nombre de symboles aligner est important. Algorithme : Pour i de 0 Nombre de lignes { Tester la ligne (i, 0, +0, +1) Tester la ligne (i, 0, -1, +1) Tester la ligne (i, 0, +1, +1) }

// Horizontales // Diagonales (Quart haut / gauche) // Diagonales (Quart bas / gauche)

Pour i de 0 Nombre de colonnes { Tester la ligne (0, i, +1, 0) ; // Verticales Tester la ligne (0, i, +1, +1) ; // Diagonales (Quart haut / droit) Tester la ligne (Nb lignes-1, i, -1, +1) // Diagonales (Quart bas / droite) }

Le principe de la fonction Tester la ligne est dincrmenter un compteur de symboles conscutifs pour chaque position lorsquon trouve une case correspondante, et de le mettre zro lorsquon trouve une case libre ou adverse. De cette faon, on peut aisment trouver les lignes gagnantes (lorsque le compteur est gal ou suprieur au nombre de symboles aligner) pour ensuite, par exemple, les afficher sur un fond vert.

20

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique Fonction Tester la ligne (Ligne : Ligne de dpart, Col : Colonne de dpart, OffsetV : Dplacement vertical, OffsetH : dplacement horizontal). Cette fonction marque les cases qui sont gagnantes et dtermine le joueur vainqueur Dfinitions // Case virtuelle pour permettre le parcours de la ligne R = Ligne de dpart C = Colonne de dpart Nb = 0 // Nombre de symboles conscutifs C : Liste de coordonnes de cases conscutives Dbut Faire { Si la case courante est joue par le joueur { Ajouter la case C Incrmenter Nb de 1 } Sinon { Vider C Nb = 0 } Dplacer la case (curseur) de {offsetV, offsetH)} Si ( Nb >= Nombre de symboles minimum aligner ) { Marque le joueur comme gagnant Pour chaque case de C { Marque la case comme gagnante } Vide C . } } Tant que ( La case virtuelle est dans les limites de la grille ) ;

Fin

PS : Les + sont uniquement utilises pour amliorer la lisibilit pour indiquer clairement quil sagit dune valeur qui peut galement tre ngative (un dplacement).

21

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

6. Le systme graphique
a. LAPI

Pour crer une interface graphique, on doit utiliser une Librairie graphique . Il en existe plusieurs, certaines intgres dans Java, et dautres quil faut installer en plus (par ex : JBuilder). Nous souhaitons utiliser une librairie standard et intgre pour viter lajout de programmes supplmentaires, nous avons alors le choix entre AWT et Swing . Les deux solutions permettent dafficher un rendu graphique identique peu importe le systme dexploitation Swing est plus rcent et optimis que AWT Swing gre les Widgets AWT est mieux reconnu auprs des tlphones portables adapte notre projet (Programme pour

La solution retenue est Swing car elle est ordinateur, multiplateformes) et est performante.

Exemple (cration dune fentre avec Swing) : JFrame frame = new JFrame() ; frame.setTitle("Nom de lapplication"); frame.setSize(400, 300); frame.setLocationRelativeTo(null); // Centre la fentre frame.setResizable(false) ; frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); // Ferme lapplication lorsque on clique sur la croix de fermeture

22

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique b. Les composants

Un grand nombre de composants sont fournis dans cette API, nous avons :

JFrame JPanel

Fentres, popups Les panneaux, par exemple : la vue des paramtres, du jeu. Dans notre cas, la fentre principale inclut un seul panneau que lon remplace lorsquon veut changer de vue. Le menu et ses lments On lassigne la fentre principale Les labels (texte simple ou code HTML) Les boutons de validation. On utilise galement des boutons pour afficher les cases de la grille.

JMenu JMenuItem JLabel JButton

c. Les dispositions

Par dfaut, lorsquon ajoute des composants un panel ceux-ci sont ajouts lun aprs lautre, et il faut souvent utiliser un gestionnaire de disposition pour pouvoir grer laffichage. Par exemple, pour la grille de jeu, on cre un panneau auquel on ajoute (m*n) boutons, puis on dfinit une disposition en grille : GridLayout ( nombre de colonnes, nombre de lignes ), les cases seront alors disposes automatiquement en grille. Il existe des dizaines de dispositions diffrentes, dont notamment la BorderLayout qui permet de positionner cardinalement les lments (au nord/sud de la fentre), des dispositions pour afficher les lments lun aprs lautre

23

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique 4. Les vnements

On doit pouvoir grer les clics sur les diffrents composants (boutons, menus). Pour cela, la fentre ou panneau concern doit implmenter linterface ActionListener et implmenter la mthode actionPerformed qui sera excute lors dun clic. Exemple : Fonction void actionPerformed ( ActionEvent e ) { Si clic sur le bouton A : Excute A() Si clic sur le bouton B : Excute B() Si clic sur le bouton C : Excute C() }

Grce ce systme, on peut assigner des actions chaque composant cliquable. On peut galement utiliser ce systme pour effectuer des vrifications, par exemple, lors dun clic sur le bouton Lancer la partie , on vrifie auparavant sil ny a pas de doublon dans les noms des joueurs. Pour vrifier quil ny a pas de doublons, on cre une liste dans laquelle on ajoute chaque nom prsent, si lors de lajout, un nom est dj prsent, cela signifie quil ya un doublon.

24

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

7. La sauvegarde
Pour proposer une fonctionnalit de sauvegarde, jai pens deux solutions :

a. La srialisation

Le principe est de pouvoir sauvegarder ltat dun objet un moment t, et de pouvoir le restaurer ultrieurement. Le principe est de convertir un objet en une chane et de lenregistrer dans un fichier. Pour cela, il faut que la classe concerne et toutes les classes utilises directement par celleci implmentent linterface java.io.Serializable . Il faut que ces classes dclarent galement un numro de version identique (fix arbitrairement). Autrement, lors de la dsrialisation les versions des classes ne correspondraient pas et lerreur InvalidClassException serait leve. Ex : private static final long serialVersionUID = 1307579888120087545L.

Exemple pour enregistrer un objet (srialisation) : Objet o = new Objet() ; FileOutputStream fos = FileOutputStream( "o.ser" ) ; ObjectOutputStream oos = ObjectOutputStream( fos ) ; oos.writeObject( o ) ; oos.close() ;

Exemple pour rcuprer un objet (dsrialisation) : FileInputStream fis = new FileInputStream( "o.ser" ) ; ObjectInputStream ois = ObjectInputStream( f ) ; o = (Objet)ois.readObject() ; ois.close() ;

Conclusion : La solution de la srialisation est intressante et trs facile mettre en place, mais ncessite que la classe ne soit jamais modifie (par ex : nouvelle version du programme), sinon il serait possible que le fichier de sauvegarde ne soit plus reconnu, je nutiliserais donc pas cette solution mais plutt le format XML pour assurer lvolutivit du logiciel.

25

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique b. Le format XML Le format XML ( Extensible Markup Language ) est un langage informatique de balisage gnrique, libre et ouvert. Il me permet de dfinir une structure qui sera utilise dans toutes les versions du jeu pour garantir son volutivit. Au cas o la structure du fichier de sauvegarde venait changer, les futures versions pourront toujours lire les anciens fichiers. <?xml version="1.0" encoding="UTF-8"?> <save> <settings version="1.0" nbCols="3" nbPlayers="2" nbRows="3" nbSymbs="3" numPlayer="0"/> <players> <player difficulty="1" name="Joueur 1" score="0" symb="0" type="0"/> <player difficulty="1" name="Joueur 2" score="0" symb="1" type="1"/> <player difficulty="1" name="Joueur 3" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 4" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 5" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 6" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 7" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 8" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 9" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 10" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 11" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 12" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 13" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 14" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 15" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 16" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 17" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 18" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 19" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 20" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 21" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 22" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 23" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 24" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 25" score="0" symb="2" type="0"/> <player difficulty="1" name="Joueur 26" score="0" symb="2" type="0"/> </players> <cases> <case col="0" row="0">0</case> Signifie case 0-0, premier joueur <case col="0" row="1">1</case> Signifie case 0-1, deuxime joueur <case col="2" row="2">0</case> Signifie case 2-2, premier joueur </cases> </save> 26

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique La premire ligne (prologue XML) indique la version XML utilise ainsi que lencodage (Unicode), ceci permet que le fichier puisse tre lu sur la majorit des ordinateurs car lUnicode contient la majorit des alphabets existants. La partie Settings contient les paramtres du jeu : la taille de la grille, le nombre de symboles aligner, le nombre de joueurs ainsi que la version du programme. La partie Players contient les informations sur chaque joueur. La partie Cases contient la liste des cases joues.

Cration du fichier XML : Il est possible de crer le fichier directement la main, ou en utilisant une librairie. Jutiliserai la mthode DOM fournie dans Java car cela permet dune part dviter les erreurs par inadvertance, et dautre part les donnes sont directement chappes . En effet, les apostrophes doivent tre codes de telle faon quelles ne soient pas interprtes comme un sparateur par le parseur XML. Par exemple : name="Nom du joueur "test"" occasionnerait une erreur, il faut alors lencoder en &quot; qui signifie toujours apostrophe mais est gr correctement par le parseur. 1. 2. 3. 4. 5. On rcupre une instance de DocumentBuilderFactory On instancie la classe DocumentBuilder On cre un Document que lon paramtre (version XML) On cre le nud principal (root : save ) On cre chaque sous-nud ( settings , players , cases ) ainsi que les sous-nuds correspondants, il ny a pas de limite la profondeur de larborescence. On doit toujours sassurer quun nud possde bien un pre, sinon celui-ci ne sera pas prsent dans le fichier en sortie. 6. On cre un format de sortie OutputFormat auquel on assigne le document XML, on peut ensuite ajouter diffrents paramtres comme la mthode setIndenting(true) qui permet dindenter automatiquement le fichier. 7. On utilise ensuite XMLSerializer avec un format OutputFormat pour obtenir en sortie le fichier XML.

27

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

8. Les exceptions
On doit sassurer que le programme ne puisse pas planter si lutilisateur fait une mauvaise manipulation (par exemple : lentre dun caractre dans la taille de la grille alors quun chiffre est attendu). Pour cela, on vrifie simplement si la valeur attendue est un entier, puis on vrifie lintervalle (par ex : doit tre compris entre 3 et 26), et si la valeur est incorrecte, on affiche soit un message derreur, soit on la remplace par une valeur par dfaut. Cependant, certaines erreurs peuvent arriver, par exemple lors de la sauvegarde il est possible que lutilisateur nait pas les droits dcriture sur le fichier demand, une erreur est alors leve, celle-ci intercepte par le programme puis un message derreur est affich. Ce type derreur est susceptible darriver souvent, le langage Java oblige le dveloppeur grer ce cas, sinon le programme ne peut pas tre compil. Cela impose plus de rigueur mais permet dobtenir un produit plus stable et vite beaucoup de bugs et plantages contrairement dautres langages comme le C qui sont plus permissifs. Pour cela, on utilise le systme des blocs Try / Catch / Finally Exemple : try { Instructions excuter } catch { Code excuter en cas derreur dans le bloc try } finally { Code toujours excut (bloc optionnel) }

28

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

9. Les mdias
Les fichiers multimdias du jeu (les sons, images, icnes, et les rgles du jeu) sont stockes dans le dossier medias . Ce rpertoire est empaquet dans larchive Jar, ceci simplifie le dploiement de lapplication car il ny a quun seul fichier possder pour pouvoir lancer le programme. Cependant, il nest plus possible daccder directement aux donnes contenues dans larchive et il faut utiliser des chemins relatifs ainsi que des fonctions spcifiques Java pour pouvoir accder ces ressources qui sont empaquetes dans larchive.

Pour rcuprer le contenu dun fichier texte ou dun son la forme dun flux : getClass().getResourceAsStream( "/medias/rules.txt" ) ; getClass().getResourceAsStream( "/medias/clic1.wav" ) ;

Pour rcuprer les icnes des boutons, jai cre une fonction loadImageIcon qui simplifie cette opration. On rcupre une icne de cette faon : URL imgURL = getClass().getRessource( "/medias/computer.png" ) ; ImageIcon img = new ImageIcon( imgUrl ) ;

Cette faon de procder permet de sassurer que le programme est excutable dans tous les cas (depuis une archive Jar et galement depuis les sources).

29

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

10. Le systme audio


Lintgralit des jeux vidos, aussi minimes soit-ils, sont sonoriss. Jai cre une classe Sound qui permet de jouer des sons au format WAV . Pour cela, lorsquon veut jouer un son, on ouvre un Flux audio vers le fichier, puis on excute la fonction lecture grce la classe AudioPlayer fournie dans Java. On joue des dans les cases suivantes : Clic sur une case (clic1.wav ou clic2.wav, alatoirement) Un joueur gagne (victory.wav) Il ya match nul (draw.wav)

On charge le son chaque fois que lon a besoin de lappeler, cette solution est trs adapte notre cas (trs peu de sons diffrents, utilisation occasionnelle, pas de sons jouer en continu). Si on dsire utiliser un nombre beaucoup plus important de sons, ou jouer des musiques en fond sonore, il faudrait faire voluer la classe de cette faon : Pr-charger les sons et les rfrencer dans une liste Ajouter une fonctionnalit pour grer les sons en continu

30

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

11. Les Replays


Lors dun Replay, le jeu est mis dans un mode spcial pour viter que les joueurs ou lIA jouent lorsque leur tour arrive. Cette partie est gre par la vue et fait appel la liste des actions effectues (cases joues) contenues dans le modle. Algorithme : On cre une copie locale de la liste des actions car toutes les cases seront effaces. Pour chaque case de la liste : Joue la case Cette case est supprime de la liste

Pour effectuer une copie de la liste des cases (instances de Case ) il faut que cette classe implmente linterface Cloneable ainsi que la mthode clone() . public Object clone() { Object o = null; try { // On rcupre l'instance renvoyer par l'appel de la mthode o = super.clone(); } catch(CloneNotSupportedException cnse) { cnse.printStackTrace(System.err); } // Renvoi le clone return o; }

De plus, on souhaite quun temps scoule entre chaque action, sinon on ne verrait pas le droulement de la partie car la grille serait immdiatement remplie. Jai dabord pens utilis une fonction de type sleep() mais ceci bloque linterface graphique car les vnements systmes ne sont plus reus par le programme (cest le problme de toutes les applications graphiques). Il faut alors utiliser un Thread que lon va excuter intervalle rgulier jusque la liste des cases soit vide. Ensuite on redonne le contrle du programme lutilisateur.

31

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique Lancement du Thread intervalle rgulier : Timer t = new Timer(); t.schedule( new ReplayTask(), 0, model.Game.REPLAY_DELAY );

Algorithme de la fonction dexcution du Thread : Si le Replay est fini : Fin du thread Sinon { Joue la case Supprime la case de le la liste du Replay Si le Replay est fini : redonne le contrle }

32

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

12. Le systme multi-langages


La majorit des programmes et jeux actuels sont dits en plusieurs langues (au moins en franais et en anglais) pour assurer leur diffusion au plus grand nombre. Jai mis en place un systme pour pouvoir grer plusieurs langues, par dfaut le programme est excut en Franais. Pour excuter le jeu en anglais il faut excuter la commande java Morpion.jar EN . La classe I18n du package model.lang gre ceci. Elle possde une liste de mots (stockes sous la forme dun HashMap : table de correspondances : cl-valeur ) et possde des mthodes (statiques) pour rcuprer un mot, et connatre la langue utilise. Lorsque on veut ajouter une langue, on doit crer une classe (par ex : model/lang/IT.java, DE.java, PL.java, etc.) qui va contenir un constructeur qui ajoute tous les mots la liste des traductions. Jai ajout le code suivant au dmarrage de lapplication qui permet de charger dynamiquement le fichier de langue, de cette faon on na pas besoin de modifier le code existant pour ajouter de nouvelles langues.

Pour charger dynamiquement la classe de la langue (passe en argument) et excuter le constructeur : Class<?> c = Class.forName( "model.lang." + args[0].toUpperCase() ); Constructor<?>[] cons = c.getConstructors(); cons[0].newInstance( );

Pour charger manuellement un fichier de langue : new FR() ;

Pour rcuprer un mot : String mot = I18n.get("mot") ;

Si on essaie dobtenir un mot qui nexiste pas, celui-ci sera remplac par ??? et un message derreur sera affich (uniquement sur la ligne de commande).

Conclusion : Ce systme permet dajouter facilement des langues, car il suffit de crer des classes en se basant sur celles existantes, et il ny a aucune partie du code modifier. Ce systme pourrait tre volu en enregistrant les traductions dans un fichier XML ou autre, ce qui pourrait permettre dchanger des fichiers de langues entre utilisateurs, cest le cas de nombreux programmes existants.

33

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

Version anglaise du jeu

Rgles du jeu en anglais 34

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

12. Limpression de grilles de morpion (PDF)


Jai propos une option permettant de gnrer des grilles de Morpion vierges et imprimables, au format PDF. La librairie open-source iText 2.1.5 est utilise pour composer le document au format PDF, il faut donc lajouter au projet en tant que Librairie JAR externe . On cre un paragraphe contenant un titre, puis un tableau constitu de n*m cases, ensuite on enregistre le fichier (lutilisateur peut choisir le nom), et on lexcute avec la fonction : Desktop.getDesktop().open( file ).

Exemple de grille gnre : Voir lAnnexe 3

13. Documentation JavaDoc


Commenter le code source permet de faciliter sa maintenance et sa comprhension par des dveloppeurs externes, mais il est galement conseill de fournir une documentation complte du code. Pour cela il existe un outil JavaDoc (fourni avec le JDK de Java) qui permet de gnrer automatiquement une documentation au format HTML de chaque classe/proprit/mthode du projet. Pour cela, il suffit de suivre la norme de JavaDoc , il faut insrer des commentaires spcifiques avant chaque classe et mthode. Exemple : /** * Multiplie a par b * @param a Argument a * @param b Argument b * @return a*b */ public int test(int a, int b) { return a*b ; }

Il existe plusieurs tags dont : @author @exception @param @return @see @version Le nom du dveloppeur Une exception lance par la mthode Un argument de fonction La valeur de retour Renvoi vers une autre classe Version

La documentation JavaDoc du projet est fournie dans le rpertoire doc . 35

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

IV.

LIntelligence Artificielle (IA)

1. Prsentation
Lintelligence artificielle est le fait de donner un programme informatique la facult de raisonner comme un humain, ainsi lordinateur est capable de jouer contre dautres joueurs humains, ou mme contre dautres intelligences artificielles. Ce principe est utilis dans la majorit des jeux vidos, mme les anciens (jeux de rflexion, de stratgie, de tir, de simulation) Je vais prsenter en dtails plusieurs algorithmes couramment utiliss dans les jeux deux joueurs, somme nulle (les gains dun joueur sont loppos des gains de ladversaire) et information complte et parfaite, en effet, dans notre jeu, on accs en permanence lintgralit des informations sur la partie (positions joues et jouables), on peut connatre la liste des coups jous auparavant, et on connat le but de ladversaire, contrairement au jeu du Poker par exemple ou on ne connat ni les cartes de ladversaire, ni celles du tas. Le bluff est possible au Morpion, mais lIA ne lutilisera jamais car il est trs facile pour un joueur humain, et encore plus pour lordinateur de le dtecter. Lalgorithme que nous choisirons sera excut dans un Thread pour viter que laffichage ne soit bloqu si les calculs sont longs.

36

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

2. Complexit du Morpion
Si on cherche tester tous les coups possible (algorithme Min-Max par exemple), le premier joueur 9 possibilits, le 2me en a donc 8, et ainsi de suite jusqu quun joueur gagne ou quil yait match nul. Dans le pire des cas il ya donc 9 ! = 9 x 8 x 1 = 362 880 possibilits, en sachant que ce nombre sera amoindri parce que ds quune possibilit se conclu par une victoire dun joueur, tous les cas suivants ne sont pas valus. Ce nombre tant relativement faible pour un ordinateur (toutes les possibilits sont values trs rapidement), on peut donc utiliser cet algorithme dans notre cas. La complexit de lalgorithme est donc factorielle : O(n!)

Dans notre cas, puisque toutes les possibilits sont passes en revues par lordinateur, il est impossible de battre cet algorithme pour le mode de difficult maximal (au mieux, il ya match nul). Cest pour cela que lon va ensuite limiter le niveau de recherche (profondeur, ou nombre de coups valus lavance) pour proposer plusieurs niveaux de difficults : 3 : Facile 5 : Intermdiaire 7 : Difficile 9 : Expert (imbattable)

Si on fait jouer deux IA de mme niveau ensemble, leur comportant tant strictement identique (donc dterministe), il y aura uniquement des matchs nuls. Dans les autres jeux (Grand morpion, dames, checs), ce nombre deviendrait beaucoup plus important, sachant que la grille de jeu est de taille plus importante et quil ya des cas diffrents possibles (surtout aux checs), il faudrait alors utiliser dautres algorithmes.

37

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

3. Lalgorithme Expert / Bas sur les rgles


Cet algorithme peut tre considr comme un Automate fini et dterministe . On dispose dune base de connaissances (chaque cas possible) et de rgles et on associe une action chaque cas. Par exemple : Si ladversaire joue au centre (2B), lIA joue en haut gauche (1A) Si jeu en 1A, joue en 3C Si ladversaire possde 2 pions aligns et une case vide, bloque la ligne

Dans le cas classique (3x3), vu le nombre de possibilits relativement faible, il est possible de concevoir une IA imbattable (qui naura que des victoires ou match nul) et trs performante en terme de rapidit dexcution. Cependant, cet algorithme ne peut que fonctionner en mode classique (3x3).

38

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

4. La fonction dvaluation
Cette fonction sera utilise par les algorithmes dvaluation qui utilisent des Arbres (expliqu plus loin). Pour valuer un nud (partie possible), on attribue une valeur leve sil ya victoire, et inversement une valeur faible sil ya dfaite. Il reste cependant un problme notre fonction dvaluation, en effet, sil ya plusieurs possibilits de victoires, lalgorithme ne va pas forcment choisir la solution la plus rapide. Pour cela, on propose lalgorithme suivant qui fonctionne de la faon suivante : Si il ya victoire, le nud vaut 1000 le nombre de pions. Donc on choisit toujours la victoire la plus rapide possible, puisque la valeur sera plus grande pour les premiers coups, sachant que la valeur la plus grande correspond au meilleur coup jouable possible . Sil ya dfaite, le nud vaut -1000 + le nombre de pions. Idem, ici on cherche repousser la dfaite, si celle-ci est invitable, en esprant que ladversaire commette une erreur. Sil ya match nul, le nud vaut 0 Si la partie nest pas termine, on calcule la valeur intermdiaire du nud.

Algorithme de la fonction dvaluation :

Sil ya match nul : Score = 0 Sil ya victoire : Score = 1000 le nombre de pions Sil ya dfaite : Score : -1000 + le nombre de pions Sinon, si la partie nest pas finie : Valeur intermdiaire { Score = 0 Pour chaque ligne { Sil ya au moins un pion de chaque joueur, ne fait rien Sil ya 2 pions du joueur, Score = Score + 30 Sil ya 2 pions de ladversaire, Score = Score 30 Sil ya 1 pion du joueur Score = Score + 10 Sil ya 1 pion de ladversaire Score = Score - 10 } } Retourne le score

39

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

5. Lalgorithme Min-Max
Prsentation : Cet algorithme fonctionne pour les jeux deux joueurs somme nulle. Son principe est dessayer (en arrire-plan) tous les coups possibles et dattribuer une valeur chaque situation de jeu (une valeur grande : le joueur gagne, une valeur faible : ladversaire gagne). Cet algorithme est parfait pour un cas ou il ya un nombre relativement faible de possibilits, par exemple le morpion 3x3, mais est inutilisable tel quel dans les autres jeux (grand morpion, dames, checs...).

Larbre de jeu : Lorsque lon cherche anticiper tous les coups possibles (en profondeur), on construit implicitement un Arbre ou chaque nud (partie possible) est tiquet par une valeur correspondant son valuation.

On value tous les nuds puis on fait remonter la valeur la racine, et on slectionne la valeur la plus grande qui correspond au meilleur coup jouable. Dans tous les cas, on calcule la meilleure valeur possible, on suppose donc que ladversaire joue de faon optimale. On privilgie lattaque la dfense (donc sil ya une possibilit directe pour le joueur de gagner, le coup est jou, puis ensuite si il ya dfaite imminente, on bloque lalignement).

40

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

Algorithme : Pour chaque coup possible correspond : Pour r de 0 Nombre de lignes { Pour c de 0 Nombre de colonnes { Si la case {r,c} est libre { } } }

Fonction MinMax ( profondeur ) { Max := -INFINI (ou valeur la plus basse possible) Pour chaque coup possible { Joue la case {r,c} : cases[r][c] := 1 Val := calcMin( profondeur 1 ) // Valeur du nud Min

// Si le coup est bon Si ( Val >= Max ) { Si ( Val > max ) { Max = Val ; Vide la liste des bons coups } Ajoute le coup la liste des bons coups } Annule le coup : cases[r][c] := 0 } } 41

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

Fonction calcMin ( profondeur ) { Si la partie est finie ou la profondeur = 0 { Retourne lvaluation du jeu (valeur du nud) } Sinon { Min = +INFINI (ou plus grande valeur possible) Pour chaque coup possible { Joue la case {r,c} : cases[r][c] = -1 ; // Adversaire Min = Minimum entre Min et calcMax( profondeur 1 ) ; Annule le coup : cases[r][c] := 0 } } Retourner Min } Fonction calcMax ( profondeur ) { Si la partie est finie ou la profondeur = 0 { Retourne lvaluation du jeu (valeur du nud) } Sinon { Min = -INFIN Pour chaque coup possible { Joue la case {r,c} : cases[r][c] = 1 ; Max = Maximum entre Min et calcMin( profondeur 1 ) ; Annule le coup : cases[r][c] := 0 } } Retourner Max }

42

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

6. Llagage Alpha-Bta
Cet algorithme permet de rduire le nombre de nuds parcourus par lalgorithme Min-Max . En effet, lors du parcours de larbre on se rend compte quil est inutile de parcourir certains nuds, on peut alors les ignorer tout en conversant les mmes rsultats. On choisi deux valeurs Alpha et Bta tels que Alpha < Bta et ces valeurs doivent tre comprises entre Min et Max. Lorsquon value les enfants dun nud de type Min , si on trouve par exemple la valeur 20, et quensuite on trouve une valeur infrieure (15), il est alors inutile de parcourir les enfants de ce nud car on cherche la valeur la plus grande possible. Le principe est le mme, mais invers lorsquon value les enfants dun nud de type Max . Alpha et bta forment donc un couple (une fentre) *a,b+ et on nvalue que les nuds prsents dans lintervalle, ce qui permet dconomiser le parcours dun nombre important de nuds. Algorithme : Pour chaque nud { Si n est un nud de type Min { Pour chaque possibilit { Si alpha < beta { Alpha = Maximum entre alpha et Valeur du nud Retourner alpha } } } Si n est un nud de type Max { Pour chaque possibilit { Si alpha < beta { Alpha = Minimum entre alpha et Valeur du nud Retourner bta } } } }

43

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

7. La convention NegaMax
Par dfinition, minimiser une valeur revient maximiser loppos de cette valeur, on peut alors simplifier les algorithmes prcdents du point de vue du code, la complexit en temps et en mmoire restant identiques. Par exemple, chaque appel rcursif de la fonction : Valeur = -negaMax( ) Il nest plus ncessaire de chercher distinguer les nuds de type Min de ceux de type Max .

8. LIA Alatoire
Bien que cet algorithme soit utilis comme une IA, celui-ci nest pas une intelligence artificielle car son comportement est purement alatoire. Le principe est simpliste, la fonction parcours la grille et mmorise les coordonnes des cases libres, puis retourne une case au hasard parmi la liste. Algorithme : Odds : Liste de possibilits (provient de la classe AI) Pour r : chaque ligne horizontale Pour c : chaque ligne verticale Si la case est libre : Ajoute {r, c} Odds Fin pour c Fin pour r

Cette IA est trs simple battre puisque elle joue uniquement alatoirement et ne joue pas les coups vidents (par exemple : sil ya possibilit immdiate de gagner, ou de bloquer un coup menant une dfaite directe).

44

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

9. Implmentation
Lorsque lordinateur doit jouer, on appelle lIA souhaite, puis on rcupre les coordonnes de la case jouer. Par exemple, pour lIA MinMax : AI ai = new MinMax( profondeur ) ; int[] c = ai.getOdd() ;

La classe AI est la classe mre, elle contient les valeurs communes toutes les IA comme la taille de la grille, la liste des cases, ainsi quune fonction pour rcuprer les coordonnes du meilleur coup possible. La classe ClassicAI drive de AI et est la classe mre des IA qui fonctionnent de manire classique (grille 3x3, 2 joueurs). Cette classe possde une particularit car elle copie localement la grille actuelle en une grille optimise ou 0 indique une case libre, 1 une case joue par le joueur et -1 par ladversaire). On nutilise pas les fonctionnalits ( getCase(), play() ) propose par la classe du jeu, mais on travaille directement sur le tableau (par ex : cases*r+*c+ = 1), cela permet doptimiser la rapidit de lalgorithme car on vite un grand nombre dappels des fonctions / classes (coteux en mmoire et en temps dexcution). LIA Random fonctionne pour le cas gnral, et drive donc directement de AI , et ne ncessite pas de grille optimise car elle est excute quasi-instantanment (une seule passe dune boucle r*c).

45

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique 10. Possibilits dvolution

Le systme propos permet dajouter de nouvelles IA. On pourrait par exemple ajouter une IA se basant sur les rgles (systme Expert ) en crant une classe Expert drive de ClassicAI . On pourrait galement ajouter dautres types dIA, comme un algorithme qui ne chercherait pas gagner, mais perdre (lexact oppos de la version standard), ou un programme qui chercherait gagner en ayant plusieurs alignements qui se rejoignent. Pour crer une IA qui fonctionne dans le mode gnral (grille : m*n, X joueurs), il faut utiliser de prfrence lalgorithme Alpha Beta car la complexit en temps du Min-Max devient trop importante. Pour que lIA fonctionne avec plus de deux joueurs, il faut trouver de nouvelles mthodes car celles existantes ne sont pas adaptes (prvues pour des jeux deux joueurs somme nulle).

46

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

V.

Conclusion
Ce projet t trs intressant et enrichissant pour moi car il ma permis damliorer mes comptences en ralisation de projet (livraison dun produit fini partir dun cahier des charges fourni), et en dveloppement dapplications Java ce qui est un avantage certain en entreprise.

Le projet m permis de travailler sur les interfaces graphiques et de devoir grer tous les problmes inhrents (mise jour de laffichage, gestion des vnements, des Threads pour que les calculs effectus par lIA ne bloquent pas laffichage). Jai galement pu voir en dtail des procds spcifiques et techniques comme les patrons de conception ( Singleton ), linternalisation de logiciels ( I18n ).

Le projet m permis dtudier la Thorie des jeux ainsi que le dveloppement dalgorithmes complexes ( Intelligence Artificielle, Arbres n-aires ). Les algorithmes tudis ici peuvent tre utiliss pour dautres jeux comme le Puissance 4 ou les Echecs, mais galement dans des applications professionnelles de gestion.

Je me suis concentr depuis le dbut du projet sur les points suivants : Le respect du cahier des charges La production dune application performante, stable et agrable utiliser La production dun code lisible, intelligent et comment Que le projet soit facilement rutilisable et volutif La fourniture dune documentation Utilisateur et Dveloppeur

Pour conclure, il est donc facile de faire voluer le projet, de lui ajouter de nouvelles langues, de nouvelles Intelligence Artificielles, ainsi que de nouvelles fonctionnalits. Puisque les couches sont spares, il est possible de faire fonctionner le programme sur un tlphone portable ou sur internet via une applet JSP en rcrivant la partie graphique gui , il nest pas ncessaire de modifier la partie modle model ce qui reprsente un gain de temps extrmement important.

47

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

VI.

Annexes
1. Linterface de dveloppement (IDE) utilise : Eclipse
Voici lIDE utilis pour la conception de notre jeu. Ce programme simplifie fortement la conception de programmes (notamment en Java) en proposant lauto-compltion du code, le contrle des erreurs avant compilation, le dbogage, la cration automatique darchives excutables JAR.

48

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

2. Le logiciel utilis pour les diagrammes : ArgoUML


Ce logiciel aide la conception de diagrammes UML et Java et surtout permet la gnration automatique de classes depuis le code source dune application.

49

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

3. Exemple de grille de Morpion imprime via le logiciel (10x10)

50

Projet logiciel 2008 / 2009 Alexandre THIL L3 Mathmatiques & Informatique

4. Exemple de jeu complexe


Voici un exemple dune partie sur une grille de 26x26, avec 3 symboles aligner, et 26 joueurs tous contrls par lIA Trs facile (Alatoire). La partie t remporte par le joueur L .

51