CONTAT Gauthier

ESIEE Paris

26/04/2016

Rapport A3P : ZuulBad

Le voyage de Guillaume

1

Table des matières

Présentation

A) Auteur .................................................................. 2

B) Thème .................................................................. 3

C) Résumé du scénario ............................................. 3

D) Plan du jeu ........................................................... 3

E) Scénario détaillé ................................................... 4

F) Présentation des lieux, personnages, items ........ 4

G) Situation gagnante/perdante .............................. 5

H) Commentaires personnels ............................... 5/6

Réponse aux exercices

A) Liste officielle des exercices ................................. 7

B) A savoir expliquer ............................................... 14

Anti Plagiat

A) Déclaration anti plagiat ....................................... 18

2

Nom Prénom : Contat Gauthier

ESIEE Paris 1ère année groupe 3

Mail: gauthier.contat@edu.esiee.fr

Site internet : http://perso.esiee.fr/~contatg

3

Phrase thème validée : Le personnage doit arriver le plus vite possible à San Francisco

Guillaume est un ami à vous avec lequel vous devez rejoindre San-Francisco, votre

aventure commence dans le métro parisien. Vous devrez arriver le plus vite possible à San

Francisco en faisant des choix de trajets !

Vos choix seront-ils les bons ?

4

Personnages du jeu :

-Guillaume

-Un contrôleur

-Un voyageur

-Des vendeurs

Items disponibles :

-Une carte du jeu

-Un pass voyage illimité

-Café

-Chocolat

-Muffin

-Cookie

-Un CV

-Une lettre

-Téleporteur

-Un thé

Guillaume est un ami à vous depuis l’enfance, il a un rendez-vous important à San

Francisco et veut que vous l’aidiez à arriver là-bas le plus vite possible ! Vous devez donc

en sortant du métro parisien en empruntant le chemin qui est selon vous le plus rapide ! Il

vous faudra aussi ramasser un pass illimité pour emprunter tous les vols dont vous aurez

besoin ! Vous devrez arriver le plus vite possible à San Francisco en faisant des choix de

trajets, vous pourrez passer dans plusieurs villes américaines connues, non pour profiter de

la vue mais surtout pour vous rapprocher pas à pas de votre destination finale !

Différents lieux possibles :

-Métro Parisien

-Aéroport Charles de Gaulle

-Aéroport de New-York

-Aéroport de Salt Lake city

-Aéroport de Denver

-Aéroport de Houston

-Aéroport de Los Angeles

-Aéroport de San Francisco

-Aéroport de Phoenix

-Aéroport de Las Vegas(Transporter)

5

Situation gagnante :

Arrive à San Francisco avec le cv et la lettre de motivation de guillaume avant

d’avoir utilisé tous ses déplacements. Il faut avoir donner les objets puis reparler à

Guillaume pour gagner.

Situation perdante :

N’arrive pas à remplir la condition gagnante.

Ne bois pas avant le timer imposer lorsque que le joueur composte le billet

Condition de fin de jeu : (Interprétation de l’exercice optionnel locked door)

Nous avions tout d’abord une condition de fin de jeu étant validé dans le cas où le joueur

arriver dans une pièce finale avec dans son inventaire les 2 objets nécessaires.

Cette condition a été amélioré et transformer en : le joueur doit donner les 2 objets à un

« character » pour pouvoir finir le jeu. (Nouvelle méthode donner créer ainsi qu’une nouvelle

classe « PNJGuillaume » étant un extends de character avec 2 booléen supplémentaires

testant si les objets ont été donner ou non).

Interaction avec les Items :

J’ai voulu rajouter des interactions avec mais item j’ai donc créer des méthodes pour

interagir avec (boire, manger conseillé par la liste officielle des exercices), j’ai poussé

l’interaction encore plus loin avec la mise en place d’une carte du jeu qui s’affiche à l’appel

de la commande « regarder » et la méthode « stop » lié à celle-ci permettant de réafficher

l’image/description de la Room actuelle.

6

Exercices optionnels :

-Look Item

Nous pouvons à présent utiliser notre commande info sur un objets pour avoir une phrase

descriptive

-StringBuilder

Constructeur de String appliqué sur la méthode getExitString()

-timer temps réel

J’ai ajouté deux utilisations du temps réel dans mon jeu, via la classe Swing.

J’ai rajouter un chronomètre permettant d’indiquer le temps que le joueur à mis pour gagner.

J’ai aussi rajouté un timer qui laisse 60 sec après avoir composter le billet , au joueur pour

boire un item de mon jeu (chocolat/cafe/the), il perd si il ne fait pas l’action.

7

Exercice 7.5 (printLocationInfo) :

Nous avons dû créer une méthode permettant d’indiquer les sorties disponibles de la pièce

ainsi que son nom soit la description de cette pièce, cette méthode a été créer pour être

appeler et éviter la duplication de code.

Exercice 7.6 (getExit) :

Pour réduire le couplage entre la classe Game et le classe Room, nous avons passez

certains attributs privés à leurs classes correspondantes et créer un accesseur (getExit())

permettant de récupérer les sorties disponibles des pièces dans cette méthode seule et

pouvoir faire appel à cette méthode.

7.7 (getExitString) :

Méthode ressemblante à la méthode getExit, nous retournons juste l’information sous le type

d’une chaine de caractère (String).

Exercice 7.8 (HashMap, setExit) :

Les attributs de la classe Room faisant référence aux sorties de chaque pièce on était

remplacés par un attribut de type « HashMap » qui créé un lien entre une String et une

Room et le stocke dans « exits ».

Grâce à cette HashMap, nous avons pu plus facilement attribué chaque sortie à chaque

pièce et nous avons donc réécris la méthode createRoom()

Exercice 7.9 (keySet) :

La méthode keySet est une méthode liée aux HashMap(tableaux associatif), cette méthode

liste l’ensemble des clés de la HashMap.

Nous l’avons donc utilisé pour récupérer toutes les sorties de la room actuelle (les sorties

étant les “key” de cette HashMap

8

7.10 (getExitString) :

Grâce à la méthode keySet, nous pouvons retourner les sorties sous forme de String et donc modifier

la méthode (getExit >> getExitString) ce qui permet de ressortir les sorties sous forme de chaine de

caractère composé des strings correspondants aux différentes sorties disponibles.

Exercice 7.11 (getLongDescription) :

Création d’une méthode getLongDescription permettant de généraliser les descriptions de pièces et

pouvoir retourner la description de la pièce actuelle via l’appel de cette fonction.

Exercice 7.14 (look) :

La méthode “look” permet via une commande d’afficher la description de la pièce actuelle grâce à

l’appel de la méthode getLongDescription.

7.15 (eat) :

La méthode eat ou composter dans mon cas est une méthode retournant (pour l’instant) uniquement

une String qui dit : « Vous avez validé votre billet, vous pouvez embarquer »

7.16 (showAll, showCommands) :

Création d’une nouvelle méthode dans la classe CommandWord qui permet d’afficher toutes les

commandes disponibles.

7.18 (getCommandList) :

La méthode getCommandList a remplacé la méthode showAll et retourne la liste des commandes

utilisables.

7.18.1 to 7.18.7: Recherche d’image intégration des images :

Après comparaison avec le projet zull with image, nous rajoutons la classe GameEngine et

UserInterface, la classe GameEngine reprend les méthodes de Game pour alléger cette dernière,

alors que la classe UserInterface contient le code permettant l’apparition d’une interface graphique

donc d’image/bouton etc…

De plus pour rajouter des images il nous suffit de rajouter un paramètre à l’objet room de type String,

et déclarer le nom de notre image dans GameEngine tel que :

vMetro = new Room ("Métro Parisien", "Images/metro.jpg");

9

7.18.8: Ajouter un bouton

On ajoute le bouton dans la classe UserInterface, il faut déclarer notre attribut bouton, le déclarer en

tant que bouton, ajouter la commande qu’il doit exécuter ainsi que de le placer à un endroit particulier

de notre interface graphique, exemple de bouton :

private JButton aButton;

aButton = new JButton ("retour"); // création du bouton

aButton.setActionCommand("retour"); //appelle la méthode qu’on souhaite utiliser

panel.add(aButton,BorderLayout.EAST); //place le bouton dans le panel

aButton.addActionListener(this); // ajout d’un listener sur le bouton

7.20: Création classe item

On crée donc une classe item destinée à créer des objets que nous intégrerons à nos rooms plus

tard, les items acceptent un nom et un poids soit 2 attributs.

De plus nous devons créer un attribut item dans la classe Room pour pouvoir ajouter un item à une

room.

7.21: Item description

Nous avons créé une méthode getDescription afin d’obtenir une description de notre item (nom,

description, poids)

7.22 : Ajout des items

Avec la classe item que nous avons créé nous ne pouvons ajouter qu’n item à chaque room nous

devons donc créer une “collection” pour pouvoir en ajouter plusieurs dans une seule pièce. L’outil le

plus adéquat semble être la HashMap d’items

De plus nous créons une méthode “addItem” permettant d’ajouter chaque item à sa Room

correspondantes.

10

7.22.2: Intégrer nos objets

Nous intégrons à présent nos propres objets dans notre jeu et dans nos Rooms, il faut donc créer un

nouvel item avec ses 2 paramètres (nom, poids) :

Item vBillet,vCarte,vCafe; // déclaration des items

//Créer les items

vBillet = new Item("Pass voyage illimité",20);

vCarte = new Item("Carte des voyages possibles",50);

vCafe = new Item("Café long de chez Starbucks",10);

Il faut ensuite placer les items dans les Rooms choisis :

vMetro.addItem(vBillet.getNom(), vBillet); // ajout de l’item vBillet dans la room Métro

vHouston.addItem(vCarte.getNom(), vCarte); // ajout de l’item vCarte dans la room Houston

vSaltlakecity.addItem(vCafe.getNom(),vCafe); // ajout de l’item vCafe dans la room Saltlakecity

7.23: Back

Nous créons une méthode back permettant de revenir dans la pièce précédente, pour ce faire nous

posons une variable aPreviousRoom qui prend la valeur de aCurrentRoom avant que nous changions

de room,

Et une méthode back (retour dans mon jeu) qui initialise la aCurrentRoom par la aPreviousRoom et

réaffiche les informations de cette Room.

7.26: Stack

La méthode back est très utile mais ne fonctionne que si nous changeons une fois de Room, pour

rendre cette méthode efficace à n’importe quel moment du jeu nous créons une pile de

aPreviousRoom, en utilisant la méthode Stack nous ajoutons une aPreviousRoom avant chaque

changement de salle. Grâce aux méthodes inclus dans la procédure Stack, notre méthode back

récupère alors la dernière Room de la pile pour l’instaurer en aCurrentRoom.

11

7.27/28 : Commande test

Cet exercice nous demande de créer deux fichiers texte, l’un permettant de gagner le plus rapidement

possible, l’autre pour explorer tous les recoins de notre jeu.

Les fichiers texte crée nous devons les lires et exécuter les commandes présentes dans nos fichier

ligne après ligne, nous programmerons donc :

try {

aScan = new Scanner( new File(pNomfichier+".txt"));

while ( aScan.hasNextLine() ) {

String vInstruction = aScan.nextLine();

interpretCommand(vInstruction);

// traitement de la ligne lue

}

7.29: Player

La classe Player récupère les méthodes propres au joueur de notre jeu, comme la room dans

laquelle il se situe, le poids de son inventaire ainsi que son nom. Nous avons donc muté certaines

commandes de GameEngine vers Player, et nous avons aussi créer un inventaire personnel au

joueur qui lui indique le poids disponible dans son inventaire et en conséquence les objets qu’il pourra

récupérer ou non en fonction de la place restante dans l’inventaire !

7.30 : Take,Drop

Ajout de deux méthodes, l’une permettant de ramasser un objet et l’autre de le déposer. Nous avons

dans ces méthodes du tester si les items était bien présent dans la currentRoom puis après avoir

ramasser l’objet le retirer également de la currentRoom, à l’aide de méthode addItem et removeItem

situé dans la classe Itemlist

7.31/7.32/7.33 : Poids max/inventaire

Les 3 exos ayant à peu près le même but, ils ont été faits ensemble. Tout d’abord pour pouvoir

ramasser plusieurs objets, une classe Itemlist a été créer pour pouvoir créer un inventaire au joueur

(HashMap). Nous avons donc dû réécrire les méthodes take and drop pour ajouter les Items à

l’inventaire du joueur, de plus nous avons rajouter un paramètre poids au joueur pour limiter le

nombre d’objet porter possible par le joueur.

12

7.34 : Magic cookie

Création d’un nouvel objet ainsi qu’une nouvelle commande adapter à mon scénario (manger un

muffin). Le joueur peut à présent ramasser et manger un muffin qui lui rapportera de la place

supplémentaire dans l’inventaire, ajout des places dans l’inventaire directement dans la méthode

« manger » avec un test de l’item que tente de manger le joueur.

7.35 : Zuul with Enums 1

Le projet étudier Zuul with enums permet de restructurer le jeu pour simplifier l’ajout et l’exécution des

nouvelles commandes via la création d’une nouvelle classe CommandWord. Cet ajout impacte sur les

classes CommandWords, Parser et Command.

La classe CommandWord possède donc un attribut HashMap de commandes valides.

7.35.1 : Switch

Utilisation d’un switch qui permet de simplifier la méthode interpretCommand en remplaçant tous les

else if par des test d’une même entité (La commande tapé par le joueur).

7.40/7.41/7.41.1 : Zuul with enums 2

La version zuul with enums 2 permet de simplifier toutes les déclarations de commandes de

CommandWords en 1 seul traitement de HashMap en utilisant la méthode values() dans une boucle

for each. Cela permet aussi de simplifier encore l’ajout d’une nouvelle commande car il suffit de la

rajouter à la classe CommandWord.

7.42 : Time limit

Mise en place d’un nombre de mouvement maximum au joueur à l’intérieur de la classe Player.

Modification directement dans la commande goRoom() qui ne s’exécute que si des mouvements sont

disponibles. Mise en place d’une décrémentation à chaque mouvement du joueur (fin de la méthode

goRoom())

7.43 : TrapDoor

Le scénario de mon jeu ne se prêtant pas à cet exercice j’ai décidé de ne pas implémenter de

trapDoor.

7.44 : Beamer

Création de la classe Beamer (extends Item), le beamer est un téléporteur pouvant être charger (par

la room actuelle) et décharger(téléportation vers la pièce chargé).

Cette classe accepte donc 2 attributs :

-un boolean aCharger (savoir si une pièce est chargée ou non)

-une room aRoomEnregistrer (stocker la room où la commande charger a été exécuter)

13

7.46 : TransporterRoom

Création d’une pièce qui lorsque l’on en sort nous téléporte dans une pièce aléatoire du jeu.

Création de deux nouvelles classes :

-TransporterRoom(extends Room) qui permet de créer un nouveau type de Room qui

téléportera le joueur.

-RoomRandomizer servant à créer les méthodes nécessaires pour aboutir via la création

d’une arrayList à un tirage aléatoire d’un entier entre 1 et Rmax (nombre de room de

l’arrayList), chaque entier représentant une Room.

7.46.1 Commande aléatoire

7.47 Abstract Command

Toutes les commandes de gameEngine sont passé chacune sous forme de classe extends

Command qui est devenu une classe abstraite

Une procédure execute(final Player pPlayer) a été ajouté à la classe Command et est

redéfini pour chaque commande

De plus nous avons dû modifier l’enum commandWord en le définissant avec 2 paramètre

(String, Command associé)

Pour finir nous avons dû corriger les erreurs apparues dans l’interpretCommand et le

processCommand servant au lien entre le parser et l’exécution des commandes (passages

du repérage sous forme de String à l’association d’une String à une commande.

Ils font aussi revoir tous les appels de méthode à l’intérieur des commandes pour récupérer

les attributs nécessaires (aGui, aParser)

7.47.1 Paquetages

Pour simplifier la vue et l’organisation du code nous avons utilisé la fonctionnalité du

package, nous avons donc séparer toutes nos classes pour les rassembler sous 4 packages

différents (Item, Room, Game,Command)

Toutefois lorsque dans une des classes nous faisons appelle à travers une procédure à un

attribut ou procédure d’une autre classe nous devons d’abord importer dans la classe les

pkg nécessaires (ex : import pkg_NomDuPackage.NomClasse)

14

7.48 : Character

Création d’une classe Character à deux paramètres (nom, dialogue) contenant les getters

des paramètres. L’ajout des méthodes addCharacter() et removeCharacter dans classe

Room pour pouvoir ajouter les Characters à nos rooms comme fait avec les items

précédemment.

7 .49 : Moving Character

Création d’un nouveau genre de character qui se déplace dans une room aléatoire à chaque

appel de la commande « go ».

Nous avons donc un extends de Character, nous avons rajouter une hashMap en paramètre

pour pouvoir utiliser la room aléatoire mais aussi une currentRoom qui se couple avec la

HashMap

7.53 : Main

Méthode main rajouter à la classe Game qui permet de créer un objet Game

7.54 : Sans Bluej

J’ai tester mon jeu sans Bluej via l’invité de commande, à l’aide des commandes :

-javac suivi de ma classe pour compiler

-java suivi de ma classe pour exécuter

7.63 : Fichier Test/javadoc/remplissage du jeu

A ce stade j’ai terminé les exercices obligatoires, j’ai donc rempli toute les javadoc et ajouter

tous les éléments de mon scénario.

15

Scanner : classe de la JDK qui permet la lecture des instructions tapées au clavier.

HashMap : une HashMap est une collection qui associe un élément à une key on peut aussi

l’appeler tableau associatif. Ce tableau ne peut pas avoir deux fois le même élément. Dans

notre cas nous avons 2 HashMap actuellement, une première associant une String à une

Room et la deuxième associant une String à un item.

Set : Set est un ensemble, ou une liste avec la particularité qu’il ne peut contenir

deux fois le même élément.

keySet() : la fonction keySet() s’applique à une HashMap, cette méthode permet

d’obtenir toutes les clés de la HashMap.

Boucle for each : C’est une boucle « pour », elle permet de tester des conditions

pour plusieurs éléments, par exemple d’une HashMap la boucle « for each » pourrait

vouloir dire « pour chaque élément de la HashMap, effectuer tel instruction »

addActionListener() : Cette méthode présente avec l’interface graphique permet

d’ajouter une « écoute » pour que l’interface réagisse à la saisie d’un texte ou un clic

sur un bouton

ActionListener : Classe permettant la réaction face aux actes de l’utilisateur sur

l’interface graphique

actionPerformed() : Méthode permettant d’initialiser les actions en fonction de

l’information renvoyé par le listener, par exemple telle action de l’interface effectue

telle action.

ActionEvent : Evènement d’un clic de l’utilisateur sur l’interface

getActionCommand() : Retourne une String de la commande à exécuter, exemple :

retour, aller nord, aide, composter…

getSource : méthode permettant de récupérer l’origine de l’ActionEvent

16

Stack : Stack est une collection permettant d’empiler des éléments les uns à la suite

des autres et de les traiter grâce à différentes procédures comme pop(), push(),

peek(), empty() nous utiliserons cette collection pour la méthode bac pour retenir

toutes les rooms traversées par le joueur.

pop() : Méthode permettant de récupérer le dernier élément de la pile et en le

supprimant de la pile.

push() : Méthode permettant d’ajouter un élément à la Stack

empty() : Méthode permettant de tester si la Stack est vide, ou permet de

vider la Stack

peek() : Méthode permettant de récupérer le dernier élément de la pile sans

le supprimer de la pile.

Lecture de fichiers de texte : la lecture de fichier dit « test » nous a été demander, en

effet il est pratique de pouvoir tester notre jeu via des commandes pré rentré, nous

pouvons choisir à notre guise de traiter ces fichiers texte ligne par ligne ou mot par

mot… Il existe plusieurs possibilités de traitement.

File : Classe du paquetage java.io permettant d’accéder aux fichiers externes au

projet.

Scanner : Le scanner présent à ce stade, ne fait pas que lire la commande de

l’interface mais permet de lire le fichier texte en entier

hasNextLine() : Méthode permettant de tester si notre fichier texte comprend une

ligne après celle en cour de traitement

nextLine() : Méthode permettant de passer à la ligne suivant celle qui vient d’être

traité

17

Traitement d’une exception : Base du Try {} catch {}, le try permet de tester si le

fichier demande existe et exécuter les commandes à l’intérieur, si le nom de fichier

n’existe pas il est alors une exception et affiche donc un message d’erreur.

Enum : Enum représente un type de classe qui contient une liste d’objets. Chaque

élément d’une classe de type enum est un objet java. Utiliser lors de l’enum des

commandes

.values() : cette méthode appelée sur un enum permet d’accéder à tous les objets de

l’enum.

toString : cette méthode de base en java permet de retourner sous forme de String le

nom d’un objet

Constructeur d’une classe Enum : C’est un constructeur particulier car il suffit de

lister les éléments de l’Enum ainsi que leur paramètres (ex : GO(« aller », new

Aller()) classe enum ayant un paramètre une string et une commande

Random : La classe Random fournit des générateurs aléatoires. Cette classe est

utilisée dans la TransporterRoom, puisqu’en nous avons besoin de récupérer un

élément aléatoire de l’ArrayList contenant toutes les rooms du jeu

nextInt() : cette méthode permet de retourner un entier de manière aléatoire (nous

avons donc définis un ensemble d’entier dans lequel l’entier sera tirer (ensemble =

nombre de room du jeu)

seed : paramètre d’un random, seed permet de choisir la suite « aléatoires » que

prendra la random (permet de « prédire » le comportement de Random)

Polymorphisme d’héritage : Une méthode héritant ou override d’une méthode mère

mais avec un corps différent (execute de l’exercice abstract Command)

Paquetages : Regroupement de différentes classes « liées », il faut faire attention

d’importer les pkg nécessaires à la classe dans laquelle on se situe.

Paquetages par défaut : C’est les paquetages existant si aucun autre n’est créé,

c’est celui où se trouve nos classes si aucun paquetage n’est créé.

18

-Utilisation de cours de java sur internet (explications YouTube, openclassroom)

-Javadoc de projet zull pour compréhension de méthode

-Version de Zull fourni dans la Liste officielles des exercices