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.

9

a. Les classes principales

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.

11

c. KlotskiPuzzle.java', la classe principale qui construit la recherche en

étoile

12

13

d. Resultats :