Rapport A3P : ZuulBad - ESIEE Pariscontatg/Rapport.pdf · 26/04/2016 Rapport A3P : ZuulBad Le...
Transcript of Rapport A3P : ZuulBad - ESIEE Pariscontatg/Rapport.pdf · 26/04/2016 Rapport A3P : ZuulBad Le...
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: [email protected]
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