Post on 14-Sep-2018
0
Département Mathématiques et Informatique
Cycle Ingénieur
« Génie du Logiciel et des Systèmes Informatiques Distribués »
RAPPORT DE PROJET
« Jeu de l’ÂNE ROUGE »
Réalisé par : Demander par : BENLAFQIH ZAKARIA Mme Fatiha AKIF
AISSA LAILA IHMADI NASSIMA AGOUJIM FATIMA
Année universitaire : 2015-2016
Université Hassan II de Casablanca Ecole Normale Supérieure de
l’Enseignement Technique ENSET - Mohammedia
1
Introduction
L'aboutissement d'un projet informatique est une opération complexe qui mobilise des
moyens importants en termes de temps et de personnel, donc de budget. Si on n’y prend pas
garde, on se retrouve facilement en dépassement de délai et de coût. De plus, une mauvaise
étude peut mener à un résultat non conforme à la demande. Il convient donc d'agir avec le plus
d'efficacité possible. Pour cela, il existe un certain nombre de règles simples qui permettent de
gérer le projet de façon optimale et maîtrisée.
Notre projet de Java est de réaliser un jeu de L'Âne Rouge. Ce jeu sera simplifié par rapport
aux règles du jeu normal, car il doit répondre aux contraintes du sujet. En effet, le but de ce
projet est de mettre en exergue les principes fondamentaux de la programmation objet.
Dans une première partie, nous rappellerons brièvement les règles de base du L'Âne Rouge.
Pour bien répondre au problème, puis une présentation claire et structurée de notre projet.
Dans une autre partie, nous parlerons plus précisément sur les détails du projet. Tous ce qui
concerne le code java.
Enfin, pour terminer nous parlerons des différents problèmes que nous avons rencontré lors
de la réalisation du projet et quelque illustration de ce dernier.
2
Sommaire
I. La présentation du puzzle de l'Ane Rouge .................................................................................. 3
a. Qu'est-ce-que l'Ane Rouge ? ..................................................................................................... 3
b. Données techniques sur le graphe ............................................................................................ 4
c. La solution .................................................................................................................................. 6
d. Organisation du programme .................................................................................................... 6
II. L’algorithme A* ........................................................................................................................ 7
a. Notations..................................................................................................................................... 7
b. Algorithme ................................................................................................................................. 8
III. Organisation du programme .................................................................................................... 8
a. Les classes principales ............................................................................................................... 9
b. Le module de gestion des mouvements de l'âne .................................................................... 10
c. KlotskiPuzzle.java', la classe principale qui construit la recherche en étoile .................... 11
d. Resultats : ................................................................................................................................. 13
3
I. La présentation du puzzle de l'Ane Rouge
a. Qu'est-ce-que l'Ane Rouge ?
L'Âne Rouge est parfois présenté comme un jeu d'origine thaïlandaise, le nom du jeu
en Thaïlande étant celui d'un prisonnier célèbre cherchant à s'évader : « Khun chang khun
phaen ». Il est aussi probable que ce jeu soit d'une invention récente. À la suite du succès
du Taquin ou puzzle-15 (15 carrés 1x1 dans un grand carré 4x4) en 1880, le puzzleDad's
puzzler ou Pennant puzzle introduit les rectangles 1x2 en 1909 et 1912 (deux variantes
enregistrées par copyright par L.W. Hardy aux États-Unis). Par la suite, J.H. Fleming dépose
un copyright en 1934 pour ce jeu qui est connu un peu partout à cette époque sous différents
noms : Klotski (bloc de bois) en polonais, Hua rong dao en chinois,Hakoiri musume (fille en
boîte) en japonais1, Forget-me-not ou Major Migraine Maker en anglais. Aujourd'hui, ce jeu se
retrouve sous une grande quantité de noms, seul ou avec des variantes parfois très éloignées,
sur différentes plateformes de jeu (iPhone, Ds): Block puzzle, Path puzzle, Kwirk, Professor
Layton, etc. Les variantes les plus connues et les plus proches de ce jeu
sont Century, SuperCompo et Quzzle.
La position initiale est en général celle-ci.
4
Il s'agit de faire passer le carré rouge à la place des deux carrés simples jaunes et des deux cases
vides marrons comme montré ici.
b. Données techniques sur le graphe
Il y a 65 880 placements différents des 10 pièces de ce jeu. Il y a 114 958 coups différents entre
ces placements, ce qui correspond à une moyenne de 3,48 coups par placement
approximativement. Ces placements se répartissent entre 898 composantes connexes
différentes, dont deux principales contenant chacune 25 955 placements. Ces deux composantes
sont symétriques l'une de l'autre par rapport à un axe horizontal ce qui explique qu'elles soient
deux. Chacune possède par ailleurs un axe de symétrie vertical interne, ce qui fait qu'on peut
passer d'un placement à son symétrique (par rapport à cet axe vertical) par un chemin (une suite
de coups).
5
Parmi les autres ensembles connexes, beaucoup plus petits en taille (entre 2 et 248
placements), 2 ont un axe horizontal et 18 autres ont un axe vertical. Le retournement d'un
placement peut donc se faire selon un axe vertical pour près de 80 % des placements. Le
chemin le plus long pour effectuer ce retournement mesure 120 coups. Le retournement d'un
placement selon un axe horizontal est beaucoup plus rare et mesure au maximum 7 coups. Du
fait de l'absence de composante connexe ayant un centre de symétrie, tous les demi-tours
(retournement autour d'un centre) sont impossibles pour cette structure.
Pour ce qui concerne les chemins les plus longs possibles dans une composante connexe, le
maximum est de 145 coups au sein d'une des composantes principales et varie entre 1 et 56
coups pour les autres composantes connexes. On peut amener le grand carré au milieu du côté
du bas en un maximum de 93 coups, dans un coin du bas en 85 coups, sur le bas du côté en 73
coups et sur le bas du centre en 69 coups. Le jeu de « l'âne rouge » correspond à un placement
inclus dans une des deux composantes connexes principales. Il ne peut donc pas être retourné
selon un axe horizontal ou par un demi-tour, et le retournement selon un axe vertical n'a pas
de sens (nombre de coup nul) puisque ce placement possède lui-même un axe de symétrie
vertical. Le plus long chemin à partir de ce placement mesure 124 coups. On peut amener le
6
grand carré au milieu du côté du bas en 81 coups, dans un coin du bas en 58 coups, sur le bas
du côté en 52 coups et sur le bas du centre en 48 coups. À titre de comparaison, les
configurations voisines appeléesCentury et SuperCompo dépassent celle de l'Âne Rouge sur
tous les points (138 et 135 coups pour amener le grand carré au milieu du bas, 230 et 268 pour
obtenir un retournement du placement selon un centre, etc.)
c. La solution
d. Organisation du programme
La résolution du puzzle se prête bien à une recherche en largeur dans l'arbre des possibilités. A
chaque étape de la recherche, on cherche tous les mouvements possibles qui amènent à des
configuration non encore vues, on crée ainsi de nouveaux chemins, et on recommence.
7
II. L’algorithme A*
L'algorithme A* est un algorithme de recherche de chemin dans un graphe entre
un nœud initial et un nœud final. Il utilise une évaluation heuristique sur chaque nœud pour
estimer le meilleur chemin y passant, et visite ensuite les nœuds par ordre de cette évaluation
heuristique. C'est un algorithme simple, ne nécessitant pas de prétraitement, et ne
consommant que peu de mémoire.
a. Notations
s état initial
T ensemble des états terminaux
h (x) heuristique estimant le coût de x à T
k (x,y) coût du passage de x à y, successeur de x
F(ermés) ensemble des états développés (leurs successeurs ont été générés)
O(uverts) ensemble des états générés mais non développés
g (x) coût du trajet de s à x
f (x) coût total estimé du trajet de s à T en passant par x
père (x)
état ayant généré x
8
b. Algorithme
O <- {s}; F <- Ø; g(s) <- 0; f(s) <- h(s);
Tant que O <> Ø faire
Extraire de O l'élément x tq f(x) est minimale;
Insérer x dans F;
Si x appartient à T alors Fini : Solution trouvée
Sinon // Développement de x
Pour tout y successeur de x faire
Si y n'appartient pas à F U O ou g(y) > g(x) + k(x,y) alors
g(y) <- g(x) + k(x,y);
f(y) <- g(y) + h(y);
père(y) <- x;
Insérer y dans O;
FinSi
FinPour
FinSi
FinTantQue
III. Organisation du programme
La résolution du puzzle se prête bien à une recherche des possibilités. A chaque étape de la
recherche, on cherche tous les mouvements possibles qui amènent à des configurations non
encore vues, on crée ainsi de nouveaux chemins, et on recommence.
L'organisation du programme : trois Classes JAVA
'main.java', la classe qui gère l'affichage de la solution.
KlotskiPuzzle.java', la classe principale qui construit la recherche A étoile.
'KlotskiSolver.java' la classe qui gère les déplacements des pièces et définit les états
de départ et final.
'Move.java’ et 'Block.java’ les classes qui définir la structure et des attribues de jeu.
10
b. Le module de gestion des mouvements de l'âne
On peut donc associer à chaque état rencontré l'état "symétrique", cela allège la recherche de la
solution. Pour limiter la taille de la liste des états rencontrés.