rapport sur le projet la magie de l’ecole - perso.esiee.frdurandb/rapports/rapport du projet...
TRANSCRIPT
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
a/ Présentation de la classe : ............................................................................................. 18
b/ Variables : ..................................................................................................................... 18
c/ Constructeur : ............................................................................................................... 18
d/ Méthodes : ................................................................................................................... 19
5/ La classe Command : ......................................................................................................... 21
a/ Présentation de la classe : ............................................................................................. 21
b/ Variables : ..................................................................................................................... 21
3
c/ Constructeur : ............................................................................................................... 21
d/ Méthodes : ................................................................................................................... 21
6/ La classe CommandWord : ................................................................................................ 22
a/ Présentation de la classe : ............................................................................................. 22
b/ Variables : ..................................................................................................................... 22
c/ Constructeur vide !........................................................................................................ 22
d/ Méthodes : ................................................................................................................... 22
7/ La classe Parser : ............................................................................................................... 23
a/ Présentation de la classe : ............................................................................................. 23
b/ Variables : ..................................................................................................................... 23
c/ Constructeur : ............................................................................................................... 23
d/ Méthodes : ................................................................................................................... 23
8/ La classe Item : .................................................................................................................. 24
a/ Présentation de la classe : ............................................................................................. 24
c/ Constructeur : ............................................................................................................... 24
d/ Méthodes : ................................................................................................................... 24
9/ La classe Player : ............................................................................................................... 28
a/ Présentation de la classe : ............................................................................................. 28
b/ Variables : ..................................................................................................................... 28
c/ Constructeur : ............................................................................................................... 28
d/ Méthodes : ................................................................................................................... 29
10/ La classe Character : ....................................................................................................... 30
a/ Présentation de la classe : ............................................................................................. 30
b/ Variables : ..................................................................................................................... 30
c/ Constructeur : ............................................................................................................... 30
d/ Méthodes : ................................................................................................................... 30
11/ La classe Mod : ............................................................................................................... 31
a/ Présentation de la classe : ............................................................................................. 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;
c/ Constructeur : 3 Initialisations et 1 Méthode
• 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
c/ Constructeur : 2 Initialisations et 1 Méthode
• 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.
b/ Variables : 10 variables
• 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).
b/ Variables : 2 variables
• 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
• Mod aMod : Déclaration d’un nouveau mod de jeu
• 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
20/20 à récolter pour gagner le jeu …)
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.
b/ Variables : 3 variables
• 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
• Mod aMod : Déclaration d’un nouveau mod de jeu
• 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
20/20 à récolter pour gagner le jeu …)
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)