Rapport sur le projet La Magie de l’Ecole - perso.esiee.frdurandb/rapports/Rapport du projet JAVA.pdf · Le projet La Magie de l’Ecole a été effectué dans le cadre de l’enseignement

1

Rapport sur le projet La Magie de l’Ecole

http://www.esiee.fr/~durandb/

Baptiste DURAND E1 Gr5 2014



2

Table des matières I/ Présentation du projet ............................................................................................................. 5

1/ Introduction : ...................................................................................................................... 6

2/ Résumé du projet : ............................................................................................................. 6

3/ Conventions de nommage .................................................................................................. 6

II/ Explication des classes ............................................................................................................ 7

1/ La classe Game :.................................................................................................................. 8

a/ Présentation de la classe : ............................................................................................... 8

b/ Variables : ....................................................................................................................... 8

c/ Constructeur : ................................................................................................................. 8

d/ Méthodes : ..................................................................................................................... 8

2/ La classe GameEngine : ....................................................................................................... 9

a/ Présentation de la classe : ............................................................................................... 9

b/ Variables : ....................................................................................................................... 9

c/ Constructeur : ................................................................................................................. 9

d/ Méthodes : ..................................................................................................................... 9

3/ La classe UserInterface : ................................................................................................... 15

a/ Présentation de la classe : ............................................................................................. 15

b/ Variables : ..................................................................................................................... 15

c/ Constructeur : ............................................................................................................... 15

d/ Méthodes : ................................................................................................................... 15

4/ La classe Room : ................................................................................................................ 18


b/ Variables : ..................................................................................................................... 18

c/ Constructeur : ............................................................................................................... 18

d/ Méthodes : ................................................................................................................... 19

5/ La classe Command : ......................................................................................................... 21


b/ Variables : ..................................................................................................................... 21

3

c/ Constructeur : ............................................................................................................... 21

d/ Méthodes : ................................................................................................................... 21

6/ La classe CommandWord : ................................................................................................ 22


b/ Variables : ..................................................................................................................... 22

c/ Constructeur vide !........................................................................................................ 22

d/ Méthodes : ................................................................................................................... 22

7/ La classe Parser : ............................................................................................................... 23


b/ Variables : ..................................................................................................................... 23

c/ Constructeur : ............................................................................................................... 23

d/ Méthodes : ................................................................................................................... 23

8/ La classe Item : .................................................................................................................. 24


c/ Constructeur : ............................................................................................................... 24

d/ Méthodes : ................................................................................................................... 24

9/ La classe Player : ............................................................................................................... 28


b/ Variables : ..................................................................................................................... 28

c/ Constructeur : ............................................................................................................... 28

d/ Méthodes : ................................................................................................................... 29

10/ La classe Character : ....................................................................................................... 30


b/ Variables : ..................................................................................................................... 30

c/ Constructeur : ............................................................................................................... 30

d/ Méthodes : ................................................................................................................... 30

11/ La classe Mod : ............................................................................................................... 31


b/ Variables : ..................................................................................................................... 31

c/ Constructeur : ............................................................................................................... 31

4

12/ La classe CommandWord : .............................................................................................. 31

III/ Liste des exercices ............................................................................................................... 32

1/Exercices obligatoires : ...................................................................................................... 33

2/ Exercices optionnels : ....................................................................................................... 35

IV/Ressources ........................................................................................................................... 36

Images du jeu : ...................................................................................................................... 37

Images techniques : .......................................................................................................... 37

Plan du jeu : ...................................................................................................................... 37

Salles : ............................................................................................................................... 38

Objets : .............................................................................................................................. 38

EasterEgg :......................................................................................................................... 39

Non implémentés : ............................................................................................................ 39

Personnages : ........................................................................................................................ 40

Items : ................................................................................................................................... 40

Salles : ................................................................................................................................... 40

IV/ Code source des programmes et tests ................................................................................. 41

1/ Liste des tests disponibles : ............................................................................................... 42

5

I/ Présentation du projet

6

1/ Introduction : Le projet La Magie de l’Ecole a été effectué dans le cadre de l’enseignement d’informatique

de la première année du cycle préparatoire de l’ESIEE durant l’année 2014. Réalisé

intégralement en langage JAVA par Baptiste Durand, aidé par le service informatique de

l’ESIEE, ce projet aura nécessité près de 100 heures de programmations et plus de 4000 lignes

de code si l’on exempte les commentaires. C’est donc un projet simple dans son aspect, mais

complexe dans son programme, que nous vous proposons ici de découvrir !

Le jeu vidéo intégral est disponible en téléchargement sur le site : http://www.esiee.fr/~durandb/

Je vous souhaite une bonne lecture (et bonne chance si vous testez le jeu vidéo) !!!

2/ Résumé du projet : Mme Copie, une prof fanatique, vient de prendre le pouvoir en détrônant le directeur et en

instaurant une tyrannie scolaire. Seul l'élève ayant obtenu suffisamment de bonnes notes

dans le temps imparti (avant 16H), pourra vaincre Mme Copie, obtenir son bac et délivrer les

élèves de l’infâme Magie de l'Ecole !!! Lors de ce voyage interscolaire, il devra affronter de

nombreux profs et serial-colleurs envoyés par Mme Copie pour le punir.

Bonne chance cher élève !!!

3/ Conventions de nommage Commençant par … Signification

a attribut

h collection (HashMap, ArrayList, Stack …)

p paramètre

v variable



7

II/ Explication des classes

8

1/ La classe Game : a/ Présentation de la classe : La classe Game est la classe qui permet juste d’initialiser puis de démarrer le jeu. De ce fait,

elle ne comporte qu’une seule méthode : la méthode main qui servira à démarrer le jeu

depuis un programme extérieur à ECLIPSE tel que l’invite des commandes de Windows ou le

terminal de Linux.

b/ Variables : 2 variables :

• UserInterface gui : Déclaration d’une nouvelle UserInterface

• GameEngine engine : Déclaration d’un nouveau GameEngine

c/ Constructeur : 2 Initialisations et 1 Méthode

• engine = new GameEngine(); Initialisation de la variable GameEngine

• gui = new UserInterface(engine);Initialisation de la variable User

Interface gui

• engine.setGUI(gui);Invocation de la méthode setGui contenue dans la classe

GameEngine

d/ Méthodes : Cette classe n’as qu’une seule méthode : la méthode main (soit littéralement la méthode

principale) qui se contente d’initialiser un nouvel objet type Game. Elle est déclarée static et

est de paramètre « String args », de manière à pouvoir la démarrer sans compilateur.

9

2/ La classe GameEngine :

a/ Présentation de la classe : La classe GameEngine constitue le moteur du jeu. C’est en effet cette classe qui va jouer le

rôle de « processeur du jeu » en gérant les relations avec les autres classes. Pour information,

la fonction gui.print sert à afficher le texte dans l’interface graphique (et non dans le terminal

comme c’est le cas pour System.out.println()).

b/ Variables : 7 variables

• UserInterface aGui : Déclaration d’une nouvelle UserInterface (cf classe UserInterface)

• Parser aParser : Déclaration d’un nouveau parser (cf classe Parser)

• Item aItem : Déclaration d’un nouvel Item (cf classe Item)

• Player player1 : Déclaration d’un nouveau Player (cf classe Player)

• Mod aMod : Déclaration d’un nouveau mod de jeu

• static Room vCour, vBiblio, vMaths, vLabo, vBureau, vHG, vAnglais;

• static Character vProf, vMachine, vSurveillant, vCopie, vApprendre;


• aParser = new Parser ();Initialisation de la variable aParser (cf classe Parser)

• aItem = new Item("", 0);Initialisation de la variable aItem (cf classe Item)

• player1 = new Player ();Initialisation de la variable player1 (cf classe Player)

• this.createRooms();Invocation de la méthode de création des salles et des items.

• aMod = new Mod() : initialisation des paramètres du jeu (temps limite, poid max, nb

20/20 à récolter pour gagner le jeu …)

d/ Méthodes : x méthodes

• SetGUI : Procédure de paramètre UserInterface qui initialise l’interface GUI et qui

invoque la procédure printWelcome. Elle est invoquée au début du jeu par la classe

Game

• CreateRoom : Procédure qui permet la création des salles en fonction de leurs

descriptions rentrés en paramètres (cf classe Room) (on en a ici sept : vCour, vLabo,

vBiblio, vMaths, vHG, vBureau, vAnglais). Elle permet aussi la création les Items en

10

fonction de leurs descriptions et de leurs poids rentrés en paramètres (cf classe Item).

Elle permet aussi la création de nouveaux personnages. Elle crée de nouvelles salles

grâce au constructeur de la classe Room et positionne leurs sorties (sous la forme

direction + salle) grâce à la procédure setExit de la classe Room. Elle crée de nouveaux

items et les positionne dans chaque salle grâce à la procédure setItem de la classe

Room et au constructeur de la classe Item. Elle procède de manière analogue avec le

procédure setCharacter de la classe Room pour possitionner les personnages. Enfin,

elle initialise le lieu courant (aCurrentRoom) à la salle de récréation (vCour) grâce au

setter setaCurrentRoom de la classe Player.

• goRoom : Procédure de changement de salle, invoquée quand la direction donnée par

le joueur après « aller » correspond bien à une sortie. Si le joueur n’écrit rien après «

aller », alors la fonction HassecondWord de la classe Command renverra false et

goRoom affiche alors : "Ou veut tu aller ?". Sinon, la procédure lit la direction tapée

grâce à la fonction getSecondWord de la classe Command qui retourne le second mot

tapé par le joueur dans la zone de saisie (ce second mot est alors temporairement

stocké dans la chaîne de caractère nommé direction). Par la suite, quel que soit le

second mot tapé, direction valide ou pas, la salle vNextRoom, prend la valeur de la salle

placé à la direction tapée grâce à la fonction getExit de la classe Room. Si cette valeur

est nulle (si le joueur a n’a tapé une direction valide ou si il n’y a pas de salle accessible

à la direction désirée), alors, on affiche "Oh non !!! Il n'y a pas de porte !!!". Si cette

valeur n’est pas nulle (donc si la procédure getExit revoie bien une salle), alors le lieu

actuel est stocké dans la pile aPile (grâce à la procédure push de la classe stack, on se

servira de la pile si on veut retourner en arrière), le lieu courant (aCurrentRoom) prend

la valeur de la salle vNextRoom grâce au setter setaCurrentRoom de la classe palyer

(on a donc changé de lieu), puis on utilise la procédure addtime de la classe Player pour

augmenter le temps de jeu (car dans ce jeu, la seule chose qui détermine le temps c’est

le changement de salle !) et la procédure getLongDescription de la classe Room est

invoquée de manière à affiche une description de la nouvelle salle et des sorties

disponibles. Enfin, si la fonction getImageName de la classe Room ne revoie pas une

valeur null, alors, on invoque la procédure showImage qui affiche l’image du nouveau

lieu en fonction du paramètre donné par getImageName.

• printWelcome : Procédure invoqué au début du jeu dans le constructeur de la classe

GameEngine. Elle sert avant tout à affiche un message de bienvenue (via gui.println),

puis invoque la méthode getLongDescription de la classe Room pour obtenir une

description du lieu de départ (c’est-à-dire la cour de récréation vCour). Enfin, elle

invoque la méthode showImage de la classe Interface de manière à affiche une image

du premier lieu.

11

• printHelp : Procédure invoquée quand la commande « aide » est tapée par le joueur.

Elle sert à aider le joueur grâce à l’affichage des instructions (via GUI.println) ainsi que

des commandes valides grâce à l’invocation de la fonction showCommand de la classe

Parser (on l’invoque bien évidement sur l’objet aParser initialisé dans notre

constructeur). Enfin, elle affiche le temps restant pour accomplir la quête (méthode

getTime et getRestTime de la classe Player) ainsi que la contenance de l’inventaire.

• interpretCommand : Procédure qui permet d’établir un lien entre la commande tapée

sur le clavier et ce qu’elle signifie. D’abord, elle affiche la commande tapée (grâce à

gui.println(commandLine);), puis, elle va premièrement stocker la valeur de la

commande dans un objet command grâce à le fonction getCommand de la classe

Parser. Dans un second temps, elle va vérifier si la commande est inconnue ou pas en

regardant si la valeur retrounée par la fonction isUnkown de la classe Command est

false ou true. Si c’est le cas, le message "Aucun rapport avec le cour du prof !!!"

s’affiche alors et le return met fin à notre procédure. Si la fonction isUnkown retourne

false, alors, cela signifie que la commande tapée est valide, via un switch (très utile

quand on doit faire une étude de cas comme là car il au lieu d’avoir à utiliser les

structures else et if avec une condition à chaque fois ; on utilise un switch de paramètre

la « commande » et ne nécessitant que les structures case pour la condition et break

pour marquer la fin de condition), on va déterminer quel en est sa signification :

- Si « aide » tapé, alors on invoque la procédure printHelp

- Si « aller » tapé, alors on invoque la méthode goRoom

- Si « regarder » tapé, alors on invoque la méthode look

- Si « inventaire » tapé, alors on affiche la méthode getInventory de la classe Item

grâce à l’item aItem. Cette méthode sert à affiche les objets contenus dans

l’inventaire du joueur.

- Si « prendre » tapé, alors on vérifie si l’on a bien un second mot après le premier

(si ce n’est pas le cas, un message d’erreur s’affiche). Si c’est le cas, alors on va

exécuter la commande « take » de la classe item avec pour paramètre le second

mot tapé.

- Si « jeter » tapé, alors on vérifie si l’on a bien un second mot après le premier (si ce

n’est pas le cas, un message d’erreur s’affiche). Si c’est le cas, alors on va exécuter

la commande « drop » de la classe item avec pour paramètre le second mot tapé.

- Si « utiliser » tapé, alors on vérifie si l’on a bien un second mot après le premier (si

ce n’est pas le cas, un message d’erreur s’affiche). Si c’est le cas, alors on va

exécuter la commande « use » de la classe item avec pour paramètre le second mot

tapé.

- Si « retour » tapé, alors on exécute la procédure de retour en arrière back.

12

- Si « test » tapé, exécute liste de commandes correspondant au test dont le nom a

été donné dans le second mot

- Si « quitter » tapé, alors on vérifie s’il n’y a pas de second mot tapé (dans ce cas le

message "Que veux-tu quitter ?" s’affiche alors. Sinon, on invoque la procédure

endGame.

- Si « charger » tapé : même combat que pour « utiliser » sauf que là, on va invoquer

la méthode load de la classe Item.

- Si « parler » tapé : Permet de parler au personnage présent dans la salle gra^ce à

la méthode speak de la classe Character (n’accepte aucun second mot car on part

du principe qu’il n’y as qu’un seul personnage par salle).

• endGame : Procédure qui sert à terminer le jeu en affichant un message de fin

(toujours via gui.println) et lance la procédure enable de paramètre false de la classe

UserInterface qui sert à empêcher l’utilisateur de saisir à nouveau du texte dans la zone

de saisie.

• look : Procédure qui affiche la fonction getLongDescription de la classe Room sur le

lieu courant (aCurrentRoom) ainsi que l’image de ce lieu (toujours grâce à la fonction

show image de la classe userinterface). Cette procédure sert donc à afficher une

description détaillée du lieu courant ainsi que son image.

• test : Procédure qui sert à lire et interpréter des fichiers textes (situés dans le dossier

« Test » cf la liste des tests) contenants des commandes permettant d’effectuer une

série de commandes. Elle va d’une part tester (bloc try) si l’un peut trouver le fichier

test correspondant au second mot en créant un nouveaux scanner (on a bien

évidement importé le package scanner au préalable) sur le bas du fichier (il faut alors

déclarer ce ficher new file (import du package io.Files nécessaire) avec le nom du fichier

corresponant au second mot tapé en paramètre (que l’on récupère grâce à la fonction

getSecondword de la classe Commande bien sûr !!!). Si c’est le cas (il faut pour cela

avoir bien spécifié l’extension du document texte qui est ici dans notre cas .txt !!!),

alors le scanner va lire ce document texte ligne par ligne grâce à une boucle while qui

tant que qu’il y a une seconde ligne à lire (on vérifie cela grâce à la fonction

hasnextLine), va lire la ligne du doc texte. Puis, toujours dans cette boucle, on va faire

appel à la fonction interpretcommand qui va tout simplement interpréter chaque ligne

de commande du fichier texte. En revanche, si le nom du fichier saisi en second mot ne

correspond pas à un fichier existant, alors, on aura une exception type FileNotFound,

qui, si elle a lieu peut être « contourné » grâce au bloc catch qui va afficher un message

d’erreur (et qui permet ainsi d’éviter un arrêt brutal et définitif du programme !)

• timeup : Procédure qui s’enclenche quand le temps impartit (enfin quand le joueur a

parcouru trop de salles et quel le compteur aTime de la classe Player a atteint une

13

valeur limite). Cette procédure se contente d’afficher « Vous êtes en retard !!! » ainsi

que l’image « Retard » et de bloquer la zone de saisie de texte (le jeu est donc perdu

!!!)

• lose : Procédure (qui n’est pour l’instant par encore utilisée dans le jeu) qui s’enclenche

quand le jeu est perdu. Elle affiche « perdu » ainsi que l’image « Game Over » tout en

bloquant la zone de saisie. Le jeu est perdu !!!

• win : Procédure qui s’enclenche quand le jeu est gagné. Elle affiche « Vous avez gagné

!!! Bravissimo !!! » ainsi que l’image « Gagné ». Elle bloque cependant la zone de saisie.

Le jeu est gagné !!!

• back : Procédure qui permet de retourner dans les salles précédemment visitées. Pour

ce faire, on va tout d’abord vérifier si la pile aPile de la classe Player n’est pas vide

(isEmpty de Player == false), si elle est vide, alors un message d’erreur spécifique

s’affiche. Ensuite, on va vérifier si le message "Oh non !!! La porte s'est refermée !!!

Vous êtes pris au piège !!!" ne s’est pas égal au résultat de la fonction getExit de la

classe Room. Si c’est le cas, alors on a affaire à une trapp door et l’on ne peut pas

retourner en arrière (une image spécifique s’affiche alors). Si on n’a pas ce message,

alors on peut revenir en arrière. Pour revenir en arrière, on va utiliser la fonction « pop

» de la classe stack (grâce à la fonction getPile de la classe Player) qui non seulement

va retourner le dernier lieu stocké, mais qui en plus va effacer ce lieu de la pile. Le

résultat de la fonction « pop » est mis en paramètre du setter setaCurrentRoom de la

classe Player de manière à ce que le lieu courant prenne la valeur de la salle précédente

: on est retourné en arrière.

• pause : Procédure qui sert à effectuer une pause de p secondes dans le jeu (en fonction

de la valeur de l’entier p rentré en paramètres). Pour y parvenir, elle va tout d’abord

tester (avec le bloc try), la méthode sleep de la classe Thread (de paramètre p*1000)

ce qui équivaut à mettre bloquer le jeu pendant ce temps en donc à effectuer une

pause. En cas d’Interrupted Exeption, on affiche le message d’erreur à l’écran sans pour

autant bloquer le jeu.

• start : Cette procédure (non officielle et totalement optionnelle) est appelée dans la

méthode printWelcome (donc au tout début du jeu). Elle se compose d’un switch qui

va en fonction du nom du joueur (que l’on obtient via la fonction returnName de la

classe Player), modifier quelques paramètres du jeu :

- Par défaut (si le nom ne correspond à aucune des propositions et donc que le

switch se réfère à la case « default »), le nom du joueur ne change pas et la difficulté

reste à normale (on affiche cela à l’écran)

- Si « facile » tapé, alors le nom du joueur devient « Débutant », et on utilise le

setter setDifficulty de la classe Mod qui va positionner la difficulté de jeu à « facile ».

Un message informant le joueur de ce changement s’affiche alors à l’écran.

14

- Si « difficile » tapé, alors le nom du joueur devient « Super Eleve », et on utilise

le setter setDifficulty de la classe Mod qui va positionner la difficulté de jeu à « difficile

». Un message informant le joueur de ce changement s’affiche alors à l’écran.

- Si « pam » tapé, alors on invoque le procédure pam (c’est-à-dire l’easter egg du

jeu).

• separation : Méthode qui retourne une ligne servant tout simplement à séparer les

différents paragraphes de textes affichés à l’écran. Cela nous permet donc de

centraliser l’affichage de cette ligne de séparation.

• getgui : Retourne l’UserInterface de la classe gameEngine. (Cette fonction n’est pour

ainsi dire utilisée que dans la classe Item quand on doit afficher à l’écran l’image de

l’item pris par le joueur).

• pam : C’est l’easter egg du jeu (c’est-à-dire la petite fonctionnalité cachée et non

officielle du jeu qui ne s’exécute que si certaines conditions particulières sont réunies).

• canwin : procédure qui déverrouille l’accès au bureau de la directrice dès que les

quatre 20/20 nécessaires pour gagner le jeu sont réunis et utilisant la méthode set exit

de la classe Room qui va positionner un accès (type trap door) vers le bureau de la

directrice). Bref, cela permet enfin d’accéder au boss final grâce à l’ouverture de le

porte, on a donc bien une la looked door.

• roomRandom : Fonction de Room qui va générer un nombre aléatoire (pour cela on a

bien pris le soin d’importer l’outil random). Un switch va en fonction du nombre

aléatoire généré, utiliser la procédure resetPile de la classe Player pour vider la pile et

va retourner une salle différente en fonction de la casse du switch correspondant au

nombre aléatoire généré. Cette procédure va servir dans la méthode goRoom pour

téléporter le joueur aléatoirement à cette sortie.

• timeMesure : méthode qui ne s’active que si la variable booléenne aTimer est

positionnée à true (cette variable est positionnée par la méthode start). Elle active la

procédure timer de la classe Player : le jeu est démarré en mode contre la montre !!!

15

3/ La classe UserInterface : a/ Présentation de la classe : La classe UserItenrface sert à coder l’interface graphique de notre jeu. En effet, c’est cette

classe qui va permettre de positionner et d’afficher les images, boutons, zones de saisie,

zones d’affichage … De plus, c’est cette classe qui va permettre l’analyse de certains

évènements tels que l’appui sur un bouton par exemple. On va devoir cependant importer

plusieurs packages tels que awt, URL (pour accéder à un fichier), event (pour déclencher une

réaction à un évènement tel que l’appui d’un boutton), image (pour afficher des images),

font (pour définir un nouvel assemblage de l’interface graphique). Pour pouvoir utiliser la

programmation évènementielle, on va implémenter l’interface ActionListener dans cette

classe UserInterface de manière à pouvoir utiliser l’écoute des boutons.

b/ Variables : 7 variables :

• GameEngine aEngine : Déclare un nouveau moteur de jeu GameEngine

• JFrame amyFrame :

• JTextField aEntryField : Déclare la zone de saisie de texte

• JTextArea aLog : Déclare la zone d’affichage de texte

• JLabel aImage : Déclare une nouvelle fenêtre qui représentera l’image

• JButton aregarder : Déclare un nouveau bouton

• JButton ainventaire : Déclare un nouveau bouton


• aEngine = gameEngine(); Initialisation de la variable gameEngine

• createGUI () ; Invocation de la méthode createGUI

d/ Méthodes : • print : Procédure qui affiche dans la zone de texte aLog, la chaine de caractère saisie

en paramètre. Pour ce faire, elle va utiliser la méthode append du package TextArea

avec pour paramètre la string mise en paramètre de la méthode. Puis

• println : Identique à la procédure print sauf que cette fois on va effectuer un retour à

la ligne à chaque appel de cette procédure (grâce à la string « \n » qui définit un saut

de ligne).

16

• enable : Procédure de paramètre booléen qui sert à bloquer (paramètre off donc false)

ou pas (paramètre on donc true) l’utilisation et l’écriture sur la zone de texte

aEntryField. Pour ce, on va invoquer la procédure setEditable du package JtextField qui

en fonction de son paramètre va autoriser ou pas le fonctionnement de la zone de

texte. Si cette procédure n’a pas de paramètres, alors on exécute la procédure

setBlinkrate.

• showImage : Procédure qui sert à afficher une image (cette image est située dans le

dossier « Images ») dans une zone dédiée à cette effet.

• actionperformed : Procédure évènementielle (donc ayant un évènement e en

paramètre). Elle va tout d’abord déterminer la provenance de l’évènement e.

- Si cet évènement provient du bouton aRegarder, (donc que la fonction getSource

de l’évènement e revoie la valeur du bouton aRegarder) alors, on exécute la

procédure look de la classe GameEngine

- Si cet évènement provient du bouton aInventaire, alors, on exécute la commande « inventaire » dans la méthode interpretecommmand de la classe GameEngine

- Si cet évènement provient du champ de texte, alors on exécute la méthode

processcommand

• processCommand : Procédure qui va récupérer le texte saisi par l’utilisateur dans le

champ de texte aEntryField grâce à la fonction getText de la classe aEntryField qui va

retourner dans la string aInput le contenu du texte saisi par l’utilisateur. Ensuite, on va

effacer le champ de saisie (tant qu’à faire !!!) en utilisant la méthode setText de la

classe aEntryField (comme on ne va mettre que des guillemets en paramètre, cette

méthode va se contenter d’afficher à la place du texte actuel … rien du tout !!!). Enfin,

on va invoquer la méthode processcommand de la classe GameEngine (avec pour

paramètre la string aInput dans laquelle on vient de stocker ce que l’utilisateur a saisi

dans le champ de texte aEntryField).

• createGUI : Procédure très importante qui va créer et positionner les composants

d’une nouvelle interface graphique en créant une nouvelle fenêtre et en INITIALISANT

les principaux composants :

- Premièrement, on va créer une nouvelle fenêtre amyFrame et le nommer « La

Magie de l’Ecole » (en paramètre de l’initialisation de cette fenêtre).

- Ensuite, cette méthode va initialiser une nouvelle zone de saisie de texte type

JTextField que l’on nomme aEntryField (de paramètre 34 car on veut saisir à l’écran

34 caractères)

- Puis, cette méthode initialise deux nouveaux boutons (aRegarder et aInventaire

mais on met leur nom dans leur paramètre d’initialisation)

17

- Par la suite, cette méthode initialise une nouvelle zone d’affichage de texte type

JTextArea que l’on nomme aLog et que l’on va ensuite rendre non éditable grâce

à la méthode setEditable de paramètre false.

- Après, cette zone d’affichage de texte va être dotée d’un outil de défilement type

JScrollPane (listScroller) que l’on va initialiser (en mettant aLog en paramètre de

façon à bien l’appliquer à notre zone d’affichage de texte).

- Ensuite, on va initialiser un nouveaux Jpanel panel (c’est-à-dire un outil permettant

de positionner les différents composants dans notre fenêtre amyFrame)

- Pour finir, on va initialiser une nouvelle image type JLabel qui servira à associer une

image à chaque salle et bien plus encore …

Dans un second temps, notre méthode createGUI, va POSITIONNER les différents

composants initialisés précédemment.

- On va tout d’abord placer une bordure dans notre panel grâce à la méthode set de

la classe JPanel

- Par la suite, on va positionner les différents composants de la fenêtre amyFrame

sur le JPanel grâce à la méthode add de la classe JPanel (2 paramètres : le

composant à placer et la bordure où il faut le placer) on place d’abord le Jlabel

aImage à la bordure nord

- Ensuite on positionne le JScrolpane listcroller à la bordure centrale

- Puis, le JTextField à la bordure sud

- Puis, le bouton aRegarder à la bordure ouest

- Puis, le bouton aInventaire à la bordure est

Dans un troisième temps, on va DEFINIR des caractéristiques de notre nouvelle

fenêtre.

- D’abord le Font policelog initialisé d’après ses paramètres à la police « Comic Sans

Ms », en gras et en taille 10

- Puis le Font policeef initialisé d’après ses paramètres à la police « Comic Sans

Ms », en gras et en taille 18

18

4/ La classe Room : a/ Présentation de la classe : La classe Room est la classe qui définit ce qu’est une Room, une salle dans notre jeu. Elle

possède les méthodes d’une salle et son constructeur. Elle nécessite cependant d’importer 3

packages dont les méthodes seront utilisés dans cette classe : Hashmap (pour faire des

collections auxquelles on accède par le biais de clés) ; Iterator (pour parcourir le HashMap) ;

Set.


• HashMap hExit : Déclaration d’un nouvel hashmap qui servira à stocker une salle en

fonction d’une clée fait d’une chaîne de caractères représentant la direction. Cette

hashmap sera utilisée pour déterminer quelle salle se situe au bout de quelle sortie.

• Arraylist hObject : Déclaration d’une nouvelle arraylist qui servira à stocker un item

dans la salle sur laquelle on appellera la fonction faisant intervenir cette arraylist.

• Arraylist hCharacter : Déclaration d’une arraylist qui servira à stocker les personnages

présents dans chaque salle

• String aDescription : Déclaration d’une chaîne de caractère représentant la description

de la salle.

• String aExit : déclaration d’une String représentant les sorties

• String aImageName : Déclaration d’une chaîne de caractère représentant le nom de

l’image à invoquer quand on entre dans la salle.

• Character aCharacter : Déclaration d’un nouveau personnage

• String aItem1, aItem2, aItem3 : Déclaration de 3 nouvelles Strings

c/ Constructeur : Le constructeur de cette classe se divise en deux parties :

• L’initialisation et la création des deux Hashmaps et l’initialisation de l’Item aItem.

• Le placement des deux paramètres de chaînes de caractères de la classe Room dans

les attributs aDescription et aItemDescription. (on utilise alors le mot this qui désigne

l’objet courant)

19

d/ Méthodes :

LES SETTERS

• setExits : Procédure qui sert à placer les salles en sorties par rapport à la direction

donnée (dans la classe GameEngine). Pour ce faire, notre procédure va tout

simplement remplir le HashMap hExits via la procédure put du package HashMap qui

sert à positionner une valeur (ici la salle de sortie) en fonction d’une clé de string (ici la

direction). Il y a en tout 6 directions possibles : nord, sud, est, ouest, haut, bas (même

si le fait d’utiliser un Hashmap permet aisément d’en rajouter d’autres).

• setItem : Même chose que la procédure setExit à la différence près que l’un va placer

des salles en fonction de clés représentés par des items. Cette procédure sert à placer

des items en fonction des salles.

• setCharacter : Idem que pour les autres setters, mais avec des characters (sert donc à

placer les personnages dans les salles)

LES GETTERS

• getDescription : Fonction de chaîne de caractères qui retourne la variable aDescription

• getExit : Fonction de chaîne de caractères qui retourne la salle présente à la direction

désirée placée en paramètre (si il n’y en a aucune, retourne la valeur null). Pour y

arriver, cette fonction va chercher dans le Hashmap Ia salle, si il y en a, à la direction

désirée via la fonction get du package HashMap (qui sert à retourner dans un hashmap

la valeur associée à la clée désirée).

• getShortDescription : Fonction de chaîne de caractères qui retourne la variable

aDescription

• getLongDescription : Fonction de chaîne de caractères qui retourne aDescription plus

le résultat de la fonction getExitString + le résultat de la fonction getItemString. Pour

retourner un retour à la ligne, on utilise « \n ».

• getImageName : Fonction de chaîne de caractères qui retourne la variable

aImageName.

• getExitString : Fonction qui retourne la direction des sorties de chaque salle sous forme

de chaîne de caractères. Premièrement, cette fonction va stocker dans la chaine de

caractère returnString, le texte "Il y a des portes au : ", puis va énumérer les directions

de sorties de la salle voulue grâce à la boucle for qui va parcourir le hashset grâce à la

variable exit et faire que la returnString prenne la valeur de la somme des sorties (ici le

caractère += peut être remplacé par returnString = returnString + exit ; c’est à dire par

20

une incrémentation). Ensuite, la variable aExit va prendre la valeur de la variable exit.

Enfin, on teste si la variable aExit est nulle ou pas. Si elle est nulle, alors, la fonction va

retourner "Oh non !!! La porte s'est refermée !!! Vous êtes pris au piège !!!" (ce qui

signifie que le joueur ne peut pas s’échapper ni utiliser la commande retour : trap

door). Sinon, elle retourne la valeur de la variable returnString.

• getItemString : Fonction qui retourne la liste des items disponibles dans chaque salle

sous forme de chaîne de caractères. Premièrement, cette fonction va stocker dans la

chaine de caractère returnString, le texte "Vous pouvez obtenir dans cette salle : ",

puis va énumérer la liste des items disponibles de la salle voulue grâce à la boucle for

qui va parcourir qui va parcourir l’arraylist et faire que la returnString prenne la valeur

de la somme des items disponibles dans la salle (ici le caractère += peut être remplacé

par returnString = returnString + items c’est à dire par une incrémentation non faite

d’entiers). Puis, les strings aItem1, aItem2, aItem3 vont prendre les valeurs des items

présents dans les salles (en fonction de leur éventuelle nullité, mais on ne peut pas

stocker plus de deux items par salle) Ensuite, la variable aItem va prendre la valeur de

la variable item. Enfin, on teste si la taille de l’arraylist est nulle ou pas. Si elle est nulle,

alors, la fonction va retourner "Vous ne pouvez rien obtenir dans cette salle !!!". Sinon,

elle retourne la valeur de la variable returnString.

• getCharacterString : Item que pour itemString ou Exit String, mais avec des characters

(cette fonction sert donc à retourner la liste dans personnages présents dans la salle).

• hasItem : Fonction booléenne qui en fonction de la string représentant la description

de l’item placée en paramètre va vérifier si cette description correspond bien à au

moins une des strings aItem1, 2 ou3. Si c’est le cas (donc que la description de l’item

placée en paramètre correspond à un item présent dans la salle), alors on retourne

true, false sinon. Bref, cette fonction sert à savoir si un item est présent dans la salle

ou pas.

21

5/ La classe Command : a/ Présentation de la classe : La classe Command est la classe qui envoie ses fonctions à la classe GameEngine. Elle sert à

envoyer à GameEngine les mots tapés dans la zone de saisie et à en déduire des choses (s’il

y a ou pas un second mot, si la commande est inconnue).


• String aCommandWord : Déclare une nouvelle chaîne de caractères

• String aSecondWord : Déclare une nouvelle chaîne de caractères

c/ Constructeur : Le constructeur de cette classe permet juste de stocker les valeurs des deux paramètres de

cette classe dans les varialbes aCommandWord et aSecondWord.

d/ Méthodes : 4 méthodes

• getCommandWord : Fonction de chaînes de caractères qui retrouve le premier mot

(aCommandWord) retourné en paramètres par la classe Parser (cf classe Parser)

• getSecondWord : Fonction de chaînes de caractères qui retrouve le second mot

(aSecondWord) retourné en paramètres par la classe Parser (cf classe Parser)

• hasSecondWord : Fonction booléenne qui sert à savoir si on a un second mot ou

pas et qui retourne true si le second mot (aSecondWord) n’est pas null.

• isUnkown : Fonction booléenne qui sert à savoir si la commande tapée au clavier

est reconnue par la classe CommandWord ou pas. Elle retourne true si le premier

mot (aCommandWord) est null (donc si la fonction isCommand de la classe

CommandWord considère la valeur comme inconnue et non valide). isUnknown

retourne false sinon.

22

6/ La classe CommandWord : a/ Présentation de la classe : La classe CommandWord est la classe dans laquelle sont stockés les commandes valides et

qui de ce fait permet de centraliser les commandes pouvant être tapés (très pratique quand

on veut en ajouter une supplémentaire.

b/ Variables : 1 variable

• static final String sValidCommands [] : Déclaration d’un tableau permettant de stocker

les commandes valides sous forme de chaines de caractères. Il est static car il est le

même pour tout le jeu et ne dépend pas de l’instanciation de CommandWord et final

car il ne changera pas au cour du jeu)

c/ Constructeur vide !

d/ Méthodes : • IsCommand : Fonction booléenne (qui retourne true ou false) qui sert à déterminer si

la commande passé en paramètre est valide ou pas. Elle parcoure le tableau

sValidCommands grâce à la boucle for qui va de i=0 à sValidCommand.lenght (c’est-

àdire la fonction qui retourne sous forme d’entier la taille du tableau). Si la commande

en paramètre correspond à une de celles du tableau, alors cette fonction retourne

true, false sinon.

• getCommandList : Fonction de chaine de caractère qui retourne une liste des

commandes valides : elle permet ainsi de centraliser l’affichage des commandes

valides. En effet, elle une parcourt une StringBuilder de manière analogue à celle de la

fonction IsCommand (boucle for) de manière à retourner chaque commande reconnue

par la fonction isCommand.

• showAll : méthode qui affiche une liste dans commandes valides à l’écran

23

7/ La classe Parser : a/ Présentation de la classe : La classe Parser sert à lire ce que l’utilisateur a tapé au clavier en décomposant la ligne lue

en un premier mot word1 et un second mot word 2 (s’il existe bien sûr !). Elle nécessite

d’abord l’importation du package String Tokenizer qui nous permettra de lire la ligne lue.

b/ Variables : 1 variable :

• CommandWords commands : Déclare un nouvel objet type CommandWord (cf Classe

CommandWord) de manière à savoir si la commande tapée correspond à une

commande valide ou pas.

c/ Constructeur : 2 Initialisations et 1 Méthode :

• commands = new CommandWords();

Permet la création et l’initialisation de la commandWord commands.

d/ Méthodes : 2 méthodes :

• getCommand : Fonction de type CommandWord de paramètre pInputLine (une chaîne

de caractères) qui permet de retourner la commande tapée au clavier. Elle déclare

d’abord le premier et le second mot (word 1 et word 2), puis initialise un nouveau

StringTokenizer : aTokenizer de paramètre la InputLine. Le StringTokenizer est une

sorte de scanner qui permet de lire la ligne saisie au clavier. Ensuite, on vérifie si on a

bien tapé le premier mot grâce à la fonction booleénne hasToken qui retourne true si

il y a un mot tapé, false sinon. Si hasToken retourne true, alors on stocke le premier

mot tapé au clavier grâce scanner aTokenizer et à la fonction nextToken du package

importé dans la variable word1. Si le premier mot est absent (hasToken qui retourne

false), alors on lui stocke la valeur null. Puis, on procède de manière analogue avec la

variable word 2 de manière à ce qu’elle prenne la valeur du second mot tapé ou null si

il n’y en as pas. Enfin, on va faire appel à la fonction isCommand de la classe

CommandWord pour déterminer si la CommandWord de paramètres word1 et word 2

est valide ou pas. Si c’est le cas, alors on retourne cette commandWord. Sinon, on

retourne une commandWord de premier paramètre null. Une commandWord a

premier paramètre null sera considérée, comme fausse par la classe Command.

• showCommands : Fonction de chaîne de caractères qui exécute la procédure showAll

de la classe CommandWords.

24

8/ La classe Item : a/ Présentation de la classe : La classe Item est la classe qui sert à stocker les propriétés remarquables des objets du jeu

(Comment on les prend, les jettent, les stockent…)

b/ Variables : x variables

• String aItemDescription: Déclare la variable qui définira la description de l’objet

• String aItemweight : Déclare la variable qui définira le poids de l’objet


• Room aRoom

• Player aPlayer1

• GameEngine aGameEngine

• Room aLoadRoom : sert dans le cas du beamer

c/ Constructeur : Après avoir pris le soin d’importer le package ArrayList, indispensable pour faire certains

types de collections, le constructeur va stocker le paramètre dans la variable et

aItemdescription. En effet, on détermine un item par son nom, puis sa description et enfin

par son poids. Pour finir, le constructeur va initialiser l’arraylist vInventory.

aMod = new Mod() : initialisation des paramètres du jeu (temps limite, poid max, nb


hWeight = new HashMap <String, String> () : initialisation du hashmap qui servira à renvoyer

un poids en fonction d’une description d’item.

d/ Méthodes : x méthodes

• getDescription : Fonction qui retourne la description de l’item qui est fournie en

paramètre de l’item.

• getWeight : Fonction qui retourne le poids de l’item. Pour ce, on va utiliser un

HashMap qui va (en fonction de la string de description de l’objet passée en

paramètre), retourner la valeur du poids correspondant, toujours grâce à la fonction

get de la classe HashMap qui retourne une string d’entier en fonction d’une String de

description de l’objet. Pour convertir des strings en entiers, on utilise la fonction

25

paserInt de la classe Integer (eh oui !!! on ne peut pas stocker des entiers dans les

hashmaps !!!).

• getInventory : Fonction servant à obtenir le contenu de l’inventaire porté par le joueur

(donc les objets qu’il possède) qui retourne une chaîne de caractères correspondant à

ce contenu. Si l’inventaire ne contient rien (c’est-à-dire si la fonction booléenne du

package arraylist « isEmpty » , appliquée à l’inventaire vInventory retourne true), alors,

on retourne la phrase « Votre cartable est vide ». Si l’inventaire vInventory contient

quelques objets, alors, on va retourner : « Votre cartable contient » + Linventory() + «

Le poids total de votre cartable vaut » + gettotalWeight(). Pour informations, la

fonction Linventory va énumérer les objets contenus dans l’inventaire sous forme «

brute ». La fonction gettotalWeight retourne un entier correspondant au poids total

de l’inventaire.

• Linventory : Cette fonction ne sert que si l’inventaire (dont on obtient les

caractéristiques via la classe Player) contient quelque chose (voir méthode «

getInventory ») Elle va utiliser une boucle for pour parcourir l’inventaire. Cette boucle

for va permettre de récupérer les différents objets présents dans l’inventaire dans la

string vContain (qui sert juste à stoker l’addition de la description et du poids des objets

de l’inventaire). En effet, à chaque nouveau bouclage, la variable vContain va non

seulement prendre la valeur de la description et du poids de l’objet (grâce à la méthode

getItem de la classe Player qui retourne l’objet contenu dans l’arraylist via la position

rentrée en paramètre), mais qui va en plus prendre ses « anciennes » valeurs. Enfin,

quand le compteur de la boucle for a atteint la taille de l’inventaire, alors notre fonction

retourne la chaîne de caractères vContain qui aura pris la valeur de toutes les

descriptions et poids des items de l’inventaire.

• weightmax : Fonction booléenne qui retourne true si le poids total de l’inventaire est

inférieur au poids maximal autorisé et false si le poids total de l’inventaire est supérieur

au poids maximal autorisé

• gettotalweight : Fonction qui retourne un entier aWeight correspondant au poids total

de l’inventaire. Pour ce faire, on va utiliser une boucle for qui tant que l’on a pas atteint

le nombre total d’items dans l’objet (on obtient ce nombre grâce à la fonction size du

package arraylist), va additionner dans le variable aWeight le poids de chacun des

objets de l’inventaire en récupérant l’objet de l’inventaire (fonction get) et en lui

appliquant la fonction getWeight. En effet, à chaque nouveau bouclage, la variable

aWeight va non seulement prendre la valeur du poids de l’objet, mais qui va en plus

prendre ses « anciennes » valeurs.

• take : Méthode qui sert à prendre l’objet (enfin sa description en string) placé en

paramètre pourvu juste qu’il soit accessible au joueur. On vérifie d’abord 1/si la

fonction hasItem de la classe Room renvoie bien true (donc que l’item est bien dans la

26

salle) ; 2/puis que la fonction weightmax nous renvoie bien true (ce qui signifie que

l’inventaire n’est pas complet) ; 3/enfin, on vérifie si l’objet que l’on cherche à prendre

n’est pas déjà contenu dans l’inventaire grâce à la fonction booléenne isInInventory(on

cherche là à éviter les doublons). Si ces 3 conditions sont réunies, alors, on affiche

l’image de cet item (fonction shwoImage de la classe GameEngine), puis on ajoute la

description de cet item dans l’arraylist vInventory de la classe Player (donc on le stocke

dans l’inventaire). Puis, on retourne « vous avez obtenu » + la description de l’item

placé en paramètre de cette procédure + « de poids » + le résultat de la fonction

getWeight + « Bravo !!! ». En revanche, si les 3 conditions citées plus haut ne sont pas

réunies, alors on ne peut pas prendre l’item et un message d’erreur spécifique à

l’erreur obtenue s’affiche.

• takeWithCharacter : Quasiment identique à la méthode take, sauf que là, on ne vérifie

pas certaines conditions pour savoir si on peut ou pas prendre l’item (si l’item est dans

la salle, si on possède déjà cet item, si le poids maximum de l’inventaire est atteint (pas

d’importance car cette méthode est utilisée pour remplacer un item par un autre item

de même poids) …)

• drop : Méthode qui sert à jeter l’objet (enfin, sa description) placé en paramètre et le

retirant de l’inventaire. Pour y parvenir, cette méthode va parcourir dans un bloc try

(on verra pourquoi après) une boucle while qui [tant que l’item (description de l’item)

passé en paramètre n’est pas égal à la valeur que l’on a obtenu de l’arraylist de

l’inventaire (fonction getItem de la classe Player toujours)], va incrémenter l’entier vi.

Si on obtient égalité des strings (fonction equals qui retourne true), alors, on a obtenu

la position dans l’arraylist de l’item à supprimer. Grâce à la procédure removeItem de

la classe Player, on le radie de l’arraylist vInventory. Enfin, on affiche le correspondant

à l’item supprimé. Cependant, cela peut générer des exceptions (notamment si l’item

à supprimer n’est pas dans l’arraylist de l’inventaire). On va alors utiliser le bloc catch

qui associé au bloc try cité précédemment, va afficher un message d’erreur sans pour

autant arrêter le programme.

• use : Méthode qui sert à utiliser l’objet (dont on a placé la description en string en

paramètre). Pour ce, on va d’abord vérifier si cet item dans l’inventaire (si ce n’est pas

le cas, on message d’erreur spécifique s’affiche alors). Si c’est le cas, alors on va utiliser

un switch (en fonction de la string placé en paramètre) qui va nous permettre de faire

une disjonction des cas. Par défaut (si l’objet n’as pas de fonction spécifique), on affiche

« vous ne pouvez pas utiliser cet objet », sinon, on associe l’objet à une fonction :

- Si c’est une magic cookie, cela augmente la taille maximale de l’inventaire grâce

au setter setweitmax de la classe Mod (on augmente la taille de l’inventaire de 4

précisément). Puis cela retire l’item de l’inventaire.

- Si c’est un bonnet d’âne

27

- Si c’est un avion en papier, alors on va exécuter la méthode beamer de la classe

GameEngine

- Si c’est une pièce de monnaie, alors on obtient une magic cookie

• canwin : Cette méthode retourne true si et seulement si l’item du joueur contient au

moins les quatre 20/20 nécessaires pour pouvoir tenter sa chance contre le boss final.

(même principe que pour drop sauf qu’au lieu de retirer l’objet de l’inventaire on teste

si la variable acw a été suffisamment incrémentée (test de condition sur son égalité de

string avec un 20/20) pour atteindre la valeur de 4). Si c’est le cas, une image et un

texte informatif s’affichent à l’écran.

• isInInventory : Fonction booléene qui va parcourir une boucle for (si la fonction

isEmpty de la classe Player ne renvoie pas false bien sûr) et retourner true si la String

passée en paramètre correspond bien à au moins une String de l’inventaire (que l’on

récupère toujours grâce à la fonction getItem de la classe Player et que l’on comparer

grâce à la fonction equals). Si ce n’est pas le cas, alors on retourne false.

• load : Méthode qui sert uniquement pour l’objet avion_en_papier. Si on charge cet

item, alors, la Room aLoadRoom va prendre la valeur de la salle actuelle et lorsque l’on

utilisera l’avion en papier, on chargera la valeur de la Room aLoadRoom dans la

procédure setaCurrentRoom de la classe Player : on est retourné dans la salle du

chargement de l’objet : on a utilisé un beamer !!!

28

9/ La classe Player : a/ Présentation de la classe : La classe Player va permettre de stocker le lieu dans lequel se situe le joueur, le nom du

joueur ainsi que le « temps » qui s’écoule.


• static string aName : Déclaration d’une chaine de caractères qui contiendra le nom du

joueur.

• Int aTime : Déclaration d’un entier servant à mesurer l’écoulement du temps.

• Int aLife : Déclaration d’un entier servant à mesurer le nombre de vies du joeur

• Int aClock : Déclaration d’un entier servant à mesurer l’écoulement du temps


• static Room aCurrentRoom : Déclaration d’une nouvelle salle, le lieu courant qui

représente le lieu dans lequel on se situe (cf classe Room)

• static Stack aPile : déclaration d’une nouvelle pile

• ArrayList <Item> aInventory : Déclare une nouvelle arraylist qui servira à stocker les

items pris, dans l’inventaire.

c/ Constructeur : La variable aTime est initialisée à 0 ;

aMod = new Mod() : initialisation des paramètres du jeu (temps limite, poids max, nb


aPile = new Stack <Room>( ) : initialisation de la pile aPile ; aTime = 0 : met le

temps de départ à zéros quelque soit le difficultée.

aInventory = new ArrayList <String> () : initialisation de l’arraylist représentant l’inventaire

du joeur.

29

d/ Méthodes :

LES METHODES QUI GERENT LE TEMPS :

• timelimit : Fonction booléenne qui sert à déterminer si le temps imparti au joueur pour

gagner le jeu est atteint ou pas. Pour ce, si l’entier aTime correspond au temps limite

(obtenu grâce à la fonction gettimelimit), alors, la fonction retourne false (ce qui veut

dire que le temps imparti est terminé et que le jeu est perdu). Sinon, si le temps aTime

n’est pas atteint (il est alors forcément inférieur), alors, cette fonction retourne true.

addTime : incrémente le variable aTime (on rajoute du temps)

• getaTime

• getTime

• getRestTime

• getaRestTime

LES METHODES QUI GERENT LE LIEU COURANT :

• setaCurrentRoom : Setter qui positionne le lieu courant

• getaCurrentRoom : Getter qui retourne le lieu courant

LES METHODES QUI GERENT LE NOM DU JOUEUR :

• getName : Getter qui retourne le nom du joueur

• setName : Setter qui positionne le nom du joueur

LES METHODES QUI GERENT LA PILE :

• setPile : additionne une salle à la pile grâce à la méthode push

• getPile : retourne la valeur de la pile grâce à la fonction pop qui retourne la dernière

valeur stockée dans la pile et la retire de la pile

• ressetPile : vide la pile

• pileEmpty : retourne true si la pile est vide

LES METHODES QUI GERENT L’INVENTAIRE :

• addItem : ajoute un item à l’inventaire qui est une arraylist grâce à la procédure add

• getItem : retourne la description de l’item correspondant à la place dans l’arraylist

signalée par l’entier en paramètre

• removeItem : enlève la description de l’item correspondant à sa place dans l’arraylist

signalée par l’entier en paramètre

• inventorySize : retourne la taille de l’inventaire

• noItem : retourne true si l’arraylist de l’inventaire est vide

30

10/ La classe Character : a/ Présentation de la classe : La classe Character est une classe qui sert à définir les caractéristiques et fonctions d’un

personnage.

b/ Variables : Il y a 4 variables dans cette classe. Elles sont toutes déclarées static (pour ne pas dépendre

de l’instanciation d’un nouveau Character) et ce sont toutes des entiers.

c/ Constructeur : Le constructeur de cette classe transfert la valeur du paramètre (String) dans la variable

aDescription.

d/ Méthodes : • getDescription : retourne aDescription c’est-à-dire la description du personnage

• speak : permet de parler avec le personnage (unique présent dans la salle). On

procéder par disjonction de nombreux cas (le switch s’impose alors). On peut générer

des exceptions type NulPointer si on parle dans une salle sans personnage ce qui est

inutile (à moins que d’être complètement fou ;) ) donc on doit utiliser un bloc try et un

bloc catch.

31

11/ La classe Mod : a/ Présentation de la classe : La classe Mod est une classe un peu spéciale (et non demandée officiellement dans le projet

A3P). Elle sert à retourner des entiers qui serviront de paramètres pour le jeu (difficulté, taille

de l’inventaire, nombre de vies du joueur, temps maximum du joueur …)

b/ Variables : Il y a 4 variables dans cette classe. Elles sont toutes déclarées static (pour ne pas dépendre

de l’instanciation d’un nouveau mod) et ce sont toutes des entiers.

c/ Constructeur : Le constructeur de cette classe sert juste à initialiser les variables telles qu’elles le sont par

défaut dans le jeu à difficulté normale (en effet, certains évènements tels que le réglage de

la difficulté au début du jeu ou encore la magic cookie, peuvent influer sur ces variables).

d/ Méthodes :

3 méthodes toutes déclarées static (ce qui nous permet de nous affranchir de l’initialisation

d’un nouvel objet mod à chaque fois qu’on veut les utiliser).

LES GETTERS :

• gettimelimit : Fonction qui retourne l’entier correspondant à la limite de temps.

• getnb : Fonction qui retourne le nombre de 20/20 (entier) à récolter pour pouvoir

atteindre le buereau de la directrice.

• getweightmax : Fonction qui sert juste à retourner le poids maximum d’objets

autorisés dans l’inventaire.

• getLife : Fonction qui retourne le nombre initial de vies du joueur

LES SETTERS :

• setweightMax : Procédure qui va changer la capacité de l’inventaire en fonction de

l’entier placé en paramètres. (dans le cas d’un changement de difficulté ou d’ingestion

de magic cookie).

• setDifficulty : Procédure qui en fonction de la string de difficulté placée en paramètre,

va repositionner les valeurs des entiers servants de paramètres au jeu (nombre de vies,

temps limite, taille de l’inventaire …).

12/ La classe CommandWord : La classe CommandWord (sans ‘s’) n’est pas vraiment une classe, c’est une enum. Elle

contient la liste des commandes valides dans le jeu ainsi qu’une méthode toString.

32

III/ Liste des exercices

33

1/Exercices obligatoires : 7.0 : page web

7.1 : zuul bad

7.11 : Choisir le thème (fait !)

7.2 : classes

7.21 : scanner

7.3 : scénario

7.31 : écrire dans le rapport

7.32 : plan du jeu

7.4 : room, exits

7.5 : printlocalinfos

7.6 : get Exit

7.7 : getExitString

7.8 : hashmap & set exit

7.8.1 : déplacement vertical

7.9 : key set

7.10 : getexit

7.10.1 : javadoc

7.10.2 : javadoc

7.11 : getLongDescription

7.14 : look

7.15 : eat (utiliser)

7.16 : show command

7.18 : getCommandList

7.18.1 : zull better

7.18.3 : chercher des images

7.18.4 : Décider du tire du jeu « La Magie de l’Ecole »

7.18.6 : zuul with image (création classe gameEngine + UserInterface pour pouvoir

afficher des images + suppression des system.out.println remplacés par des

gui.println pour afficher dans la nouvelle interface)

7.18.8 : un bouton

7.19.2 : déplacer les images (fait !!!)

7.20 : Item

7.21 : ItemDescription





34

7.22.2 : Intégrer les items

7.23 : back

7.26 : stack

7.26.1 : javadoc

7.28.1 : test

7.29 : Player

7.30 : take & drop

7.31 : porter plusieurs items

7.31.1 : ItemList

7.32 : poids max

7.33 : inventaire

7.34 : magic cookie

7.34.1 : javadoc

7.34.2 : javadoc

7.35 : zuul with enum

7.35.1 : switch

7.40&7.41 : enum

7.41.1 : enum v2

7.42 : time limit

7.42.2 : HIM graphique (non désirée)

7.43 : trap door (la salle du bureau de la directrice)

7.44 : beamer

7.45.1 : mise à jour des fichiers de test

7.45.2 : 2 javadocs

7.46 : transporter room

7.46.1 : alea (non fait)

7.46.2 : heritage

7.46.3 : javadoc

7.46.4 2 javadocs

7.47 : abstracts command (non fait)

7.47.1 : paquetages (non fait)

7.48 : Characters

7.49 : Moving Characters (non fait)

7.49.2 : Compléter le jeu (fait)

7.49.3 : 2 javadocs

7.53 : main (fait)

35

7.54 : sans ECLIPSE

2/ Exercices optionnels : 1.18.7 : fait !!!

7.57 : fait !!! voici le code :

public class class1

{

private class2 aInstance;

public class1() { aInstance = new class2(); //appel au constructeur de class2

} } public class class2

{

public static int x; // notre nb d'instances

public class2 ()

{

x++; // à chaque instanciation, on incrémente notre compteur d'instance } public static void numberofInstances()

{

System.out.println(x);

}

}

7.37

7.38

7.45 : Looked door (fait !!!)

7.42.1 : Temps réel

36

IV/Ressources

37

Images du jeu : Images techniques :

Plan du jeu :

38

Salles :

Objets :

39

EasterEgg (Petite surprise):

Non implémentés :

40

Personnages : Personnage Fonction

Elève Non implémentée

Machine à apprendre Non implémentée

Machine à cookie Implémentée

Mme Copie Non implémentée

Prof Non implémentée

Surveillant Non implémentée

Items : Item Fonction si utilisé

20/20 Il en faut 4 pour accéder au bureau de la

directrice

Avion en Papier Téléportation aléatoire

Baccalauréat Permet de gagner le jeu

Bonnet d’âne Augmente la vie du joueur

Livre Bleu Aucun

Livre Jaune Permet de gagner du temps

Livre Rouge Aucun

Livre Vert Aucun

Magic Cookie Agrandi l’inventaire

Pièce de monnaie Sert à la machine à cookie

Salles : Salle Fonction

Bureau de la directrice Fin du jeu

CDI -

Cour de récréation Début du jeu

Laboratoires -

Salle d’anglais -

Salle d’histoire géo -

Salle de maths -

Random Téléporte le joueur dans une salle au hasard

41

IV/ Code source des

programmes et tests

42

1/ Liste des tests disponibles : Les tests sont comme le nom l’indique, des fichiers texte contenant des commandes à

exécuter les unes après les autres sans avoir à les exécuter manuellement. Ils servent donc à

gagner du temps lors du débogage.

• 20 : permet d’exécuter les commandes suffisant à obtenir les quatre 20/20 nécessaires

pour atteindre le boss de fin.

• bdirect : mène directement au bureau de la directrice et teste la trap door. Test ancien,

ne fonctionne plus.

• beamer : permet de prendre l’avion en papier

• cmds : exécute les principales commandes du jeu

• hg : mène en salle d’histoire-géo

• jt : jette une magic cookie

• jt2 : jette un livre bleu

• prd : prend une magic cookie

• prd2 : prend un livre bleu

• timeup : permet d’atteindre la limite de temps (si celle-ci est fixée à 8) tele : permet

d’utiliser le beamer du jeu.

• utl : permet de prendre et d’utiliser une magic cookie

• win : permet d’entrer dans le bureau de la directrice (version du test 20 améliorée)

Documents

Rapport sur le projet La Magie de l’Ecole - perso.esiee.frdurandb/rapports/Rapport du projet JAVA.pdf · Le projet La Magie de l’Ecole a été effectué dans le cadre de l’enseignement