rapport de projet zuul - perso.esiee.frdupontl/zuul/rapport.pdf · rapport de projet zuul a3p...

Page web du projet : http://www.esiee.fr/~dupontl/zuul

Sommaire Partie I : Détective Nanko, le jeu .................................................................................................................................... 3

I. A) Auteur .................................................................................................................................................................. 3

I. B) Thème du jeu ....................................................................................................................................................... 3

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

I. D) Plan du jeu ........................................................................................................................................................... 4

I. E) Scénario détaillé ................................................................................................................................................... 5

I. F) Détail des lieux, items, personnages .................................................................................................................... 6

I. G) Situations gagnantes et perdantes ...................................................................................................................... 8

Partie II : Réponses aux exercices ................................................................................................................................... 9

7. 1................................................................................................................................................................................. 9

7. 2............................................................................................................................................................................... 10

7. 4............................................................................................................................................................................... 10

7. 5............................................................................................................................................................................... 10

7. 6............................................................................................................................................................................... 10

7. 7............................................................................................................................................................................... 11

7. 8............................................................................................................................................................................... 11

7. 8. 1. .......................................................................................................................................................................... 11

7. 9............................................................................................................................................................................... 11

7. 10............................................................................................................................................................................. 12

7. 11............................................................................................................................................................................. 12

7. 14............................................................................................................................................................................. 12

7. 15............................................................................................................................................................................. 13

7. 16............................................................................................................................................................................. 13

7. 17............................................................................................................................................................................. 13

7. 18............................................................................................................................................................................. 14

7. 18. 1. ........................................................................................................................................................................ 15

7. 18. 2. ........................................................................................................................................................................ 15

Rapport de projet Zuul

A3P 2012/2013 – 5L

http://www.esiee.fr/~dupontl/zuul

Rapport de projet Zuul A3P 2012/2013 – 5LIGI-1002 Léo DUPONT

1

7. 18. 5. ........................................................................................................................................................................ 16

7. 18. 6. ........................................................................................................................................................................ 16

7. 18. 7. ........................................................................................................................................................................ 16

7. 18. 8. ........................................................................................................................................................................ 17

7. 19............................................................................................................................................................................. 18

7. 19. 1. ........................................................................................................................................................................ 19

7. 19. 2. ........................................................................................................................................................................ 19

7. 20............................................................................................................................................................................. 20

7. 21............................................................................................................................................................................. 21

7. 22............................................................................................................................................................................. 22

7. 22. 1. ........................................................................................................................................................................ 22

7. 22. 2. ........................................................................................................................................................................ 22

7. 23............................................................................................................................................................................. 23

7. 26............................................................................................................................................................................. 24

7. 26. 1. ........................................................................................................................................................................ 24

7. 28. 1. ........................................................................................................................................................................ 25

7. 28. 2. ........................................................................................................................................................................ 26

7. 29............................................................................................................................................................................. 27

7. 30. & 7. 31. .............................................................................................................................................................. 28

7. 31. 1. ........................................................................................................................................................................ 30

7. 32............................................................................................................................................................................. 30

7. 33............................................................................................................................................................................. 31

7. 34............................................................................................................................................................................. 32

7. 34. 1. ........................................................................................................................................................................ 34

7. 35. & 7. 35. 1. .......................................................................................................................................................... 35

7. 35. 2. ........................................................................................................................................................................ 38

7. 37............................................................................................................................................................................. 39

7. 38............................................................................................................................................................................. 39

7. 41. 1. ........................................................................................................................................................................ 39

7. 42. & 7. 42. 1. .......................................................................................................................................................... 40

7. 43............................................................................................................................................................................. 41

7. 44............................................................................................................................................................................. 42

7. 45. 1. ........................................................................................................................................................................ 44

7. 46............................................................................................................................................................................. 45


2

7. 46. 1. ........................................................................................................................................................................ 46

7. 46. 2. ........................................................................................................................................................................ 46

7. 46. 3. ........................................................................................................................................................................ 46

7. 46. 3. ........................................................................................................................................................................ 46

7. 47............................................................................................................................................................................. 47

7. 47. 1. ........................................................................................................................................................................ 49

7. 48............................................................................................................................................................................. 50

Parenthèse : passage du log du jeu en HTML ............................................................................................................ 54

7. 48............................................................................................................................................................................. 55

7. 49. 2. ........................................................................................................................................................................ 58

7. 50............................................................................................................................................................................. 61

7. 51............................................................................................................................................................................. 61

7. 52............................................................................................................................................................................. 61

7. 53............................................................................................................................................................................. 62

7. 54............................................................................................................................................................................. 62

7. 56............................................................................................................................................................................. 62

7. 57............................................................................................................................................................................. 63

58. & 58. 1. .................................................................................................................................................................. 63

59. ............................................................................................................................................................................... 64

59. 1............................................................................................................................................................................. 64

60. & 60. 1. .................................................................................................................................................................. 64

60. 3............................................................................................................................................................................. 64

60. 4............................................................................................................................................................................. 65

61. ............................................................................................................................................................................... 65

62. ............................................................................................................................................................................... 68

63. ............................................................................................................................................................................... 72

63. 1............................................................................................................................................................................. 72

63. 2. & 63. 1. .............................................................................................................................................................. 72

63. 4............................................................................................................................................................................. 73

Emprunts de code ....................................................................................................................................................... 74


3

Partie I : Détective Nanko, le jeu

I. A) Auteur :

Léo DUPONT (groupe 5L).

I. B) Thème du jeu :

Dans une maison, un jeune détective doit trouver l'assassin du majordome.

I. C) Résumé du scénario :

Le joueur incarne Nanko, un jeune détective japonais âgé de 20 ans.

Son but est d'élucider le mystère de la mort de Shinichi Yamaguchi, le majordome de la famille Hikaru,

chez qui Nanko et sa cousine était invités ce soir là.

Il s'agira de se renseigner auprès des personnes présentes et de trouver le motif et les preuves du crime

afin de confronter l'assassin !


4

I. D) Plan du jeu :


5

I. E) Scénario détaillé :

Alors que le jeune Nanko et sa cousine Mouri sont invités chez Kenji Hikaru, l'oncle du jeune détective ;

un bruit sourd résonne dans la maison de la riche famille.

Nanko, Mouri et Kenji accourent alors vers la cuisine et trouvent le corps allongé de Shinichi Yamaguchi,

le majordome de la famille. Celui-ci s'est écroulé, un verre de vin à la main. L'hypothèse de l'accident

cardio-vasculaire est très vite écarté lorsque Nanko s'aperçoit que le vin bulle en touchant le sol.

C'est alors que Miss Dayme, accompagnée des jumeaux Meïdin et Chaïna, arrivent sur les lieux. La

panique s'installe jusqu'à ce que Nanko, habitué à ce genre de situations, bien que troublé par la mort du

majordome qu'il connaissait depuis son enfance, demande à tout le monde de se réunir dans le salon et

leur interdisse de bouger le temps que la police arrive.

Pendant ce temps, le détective mène son enquête et interroge les membres de la famille. Il apprend du

père Hikaru que le majordome testait toujours le vin avant de le servir. Le détective apprend ensuite que

les enfants n'étaient pas au courant de ce détail, mais que Miss Dayme l'était.

Mouri conseille alors à Nanko de se mettre à la recherche d'indices au sous-sol, près de la cave à vin. Le

détective ne trouvera rien, mais un coffre-fort attire son attention et le pousse à demander à Kenji Hikaru

ce qu'il contient. Ce dernier lui répond qu'il ne contient que quelques documents importants mais sans

valeur, ainsi que son testament. Le père Hikaru confie alors à Nanko le contenu dudit testament, celui-ci ne

désigne comme seuls héritiers que ses deux enfants et le majordome ! Le jeune détective, de nouvelles

questions en tête, et apprend que personne n’en était au courant à part Kenji Hikaru lui-même.

Nanko décide alors de fouiller les chambres de Kenji, de Meïdin et Chaïna, de Miss Dayme ainsi que

celle de Shinichi. Il découvre dans la chambre des jumeaux le journal intime de Meïdin et apprend que le

garçon de 20 ans entretenait des rapports orageux avec son père. Il trouve aussi, au fond de la corbeille de

la chambre, des épines de fugu, un poisson dont certains organes contiennent un poison très toxique… Il

redescend alors interroger les jumeaux.

Après quelques questions et l’apport des preuves par Nanko, Meïdin avoue avoir voulu empoisonner

son père en mettant du fugu en poudre dans son vin. Il ignorait alors que Shinichi testait le vin avant de le

servir au père Hikaru…

C’est à ce moment que la police arrive et embarque le meurtrier.


6

I. F) Détail des lieux, items, personnages :

Les personnages :

Nanko :

Vous.

Un jeune détective âgé de 20 ans, habitué à ce genre d'affaires et capable de détecter les indices importants

parmi tout ce que l'on peut trouver dans une scène de crime.

Mouri :

Votre cousine.

Âgée de 25 ans, c'est elle qui a découvert votre talent. Elle-même détective, elle vous aide lors de vos

enquêtes et vous soumet ses théories.

Kenji Hikaru :

Votre oncle, le père de Meïdin et Chaïna Hikaru.

Sage et respecté, Kenji vous connait depuis votre naissance. Il est âgé de 52 ans.

Meïdin Hikaru :

Le fils de Kenji et frère jumeau de Chaïna.

Âgé de 20 ans également, Meïdin vient de recommencer sa première année de médecine.

C'est un garçon calme mais facilement stressé.

Chaïna Hikaru :

La fille de Kenji et soeur jumelle de Meïdin.

À l'âge de 20 ans, Chaïna est en deuxième année dans une école d'ingénieurs du Japon.

C'est une fille brillante mais réservée.

Shinichi Yamaguchi :

Le majordome de la maison. Shinichi a passé 20 ans, soit la moitié de sa vie, à travailler chez les Hikaru.

Il est considéré comme un oncle par les enfants.

Ce soir, il a été retrouvé mort, apparemment sans raison.

Miss Dayme :

La femme de ménage de la maison.

Âgée de 31 ans, elle travaille chez les Hikarus depuis 5 ans.

Elle est très appréciée de Chaïna, qui l'aide parfois.


7

Les lieux :

Cuisine :

Le lieu où Shinichi a été retrouvé mort.

Salon :

Là où tous les PNJ (sauf Mouri) se trouvent.

Coffre-fort :

Rien ne s'y trouve, mais visiter cette pièce nous permet d'obtenir le testament de Kenji en revenant lui parler.

Chambre des enfants :

On y trouve 2 items clés de l'enquête : le journal intime de Meïdin et une épine de fugu.

Entrée :

La "salle de test" du projet : on peut y ramasser un cookie magique et un téléporteur. Il s'agit également de la

TransporterRoom : essayer de quitter cette pièce par la commande aller direction téléporte le joueur dans

une salle au hasard du jeu.

Les items :

testament :

Faux indice sur l'enquête, obtenu en parlant à Kenji après avoir visité le Coffre-fort.

journal :

Item clé de l'enquête, on y apprend que Meïdin souhaitait tuer son père.

corbeille :

La corbeille de la chambre des enfants : en la fouillant, on obtient une épine de fugu, un item clé de l'enquête.

fugu :

Item clé de l'enquête : l'arme du crime utilisée par Meïdin.


8

I. G) Situations gagnantes et perdantes :

Situation gagnante :

Le joueur gagne s'il accuse Meïdin après avoir réuni les indices suivants :

1. Avoir lu et récupéré le journal intime de Meïdin.

2. Savoir que le journal appartenait à Meïdin (en lui parlant après avoir récupéré le journal).

3. Avoir trouvé l'épine de fugu dans la corbeille de la chambre des enfants (commande

inspecter).

4. Savoir que Meïdin ignorait le fait que Shinichi goûtait le vin avant de le servir (parler au moins

une fois à Kenji, puis au moins une fois à Meïdin).

Situations perdantes :

Fin du temps imparti :

Le joueur perd s'il n'a pas résolu l'enquête dans le temps imparti (au bout d'une heure).

Trop de fausses accusations :

Le joueur perd s'il a porté 4 fausses accusations.


9

Partie II : Réponses aux exercices

7. 1. Découverte de zuul-bad

What does this application do? L'application ouvre une fenêtre de texte permettant de lire les informations envoyées par le jeu et d'entrer des commandes.

What commands does the game accept? Le jeu accepte les commandes go, quit et help.

What does each command do? La commande go permet de se déplacer d'une scène à l'autre (ex : go west) La commande quit permet de quitter le jeu. La commande help permet d'afficher des informations sur la situation du joueur et sur les commandes possibles.

How many rooms are in the scenario? Il y a 5 pièces dans le scénario.

Draw a map of the existing rooms :


10

7. 2. Rôle des classes

CommandWords : recense les mots-clés autorisés et détermine si une commande de l'utilisateur est valide.

Command : engendre une commande de l'utilisateur.

Room : permet de créer les pièces du jeu, une pièce représente une scène.

Parser : permet de lire le texte entré par l'utilisateur et le transforme en commande.

Game : est la classe principale du jeu (méthode play).

7. 4. zuul-v1, rooms, exits

Modification de la méthode createRooms() de la classe Game :

o ajout des pièces : manger, salon, laverie, cuisine, entree, escaliers. o avec leurs sorties, respectant le plan du jeu. o uniquement premier étage car problème pour les sorties de la pièce couloir, ainsi que

pour déplacement vertical

7. 5. printLocationInfo

Création d'une procédure printLocationInfo() dans la classe Game, reprenant le code

redondant des méthodes createRooms() et goRoom().

Remplacement du code dupliqué des 2 méthodes citées par l'appel de la procédure printLocationInfo().

7. 6. getExit

Ajout de l'accesseur getExit() dans la classe Room afin de réduire le niveau de couplage.

Utilisation de l'accesseur getExit() dans la classe Game (méthode goRoom()) afin de

n'utiliser que les retours de getExit().


11

7. 7. getExitString

Modification de printLocationInfo() :

private void printLocationInfo()

{

System.out.println("C'est " + currentRoom.getDescription());

System.out.print(currentRoom.getExitString());

System.out.println();

}

Définition de getExitString() sur le modèle : o if (getExit("west") != null) {vWest = "west ";}

o else {vWest = "";}

o return ("Sorties : " + vNorth + vEast + vSouth + vWest);

7. 8. HashMap, setExit

Ajout de l'outil HashMap et changements expliqués dans le livre apportés.

Méthode inutile désormais : ?

7. 8. 1. Ajout d'un déplacement vertical

Ajout de toutes les pièces du plan (niveaux -1 et 1) : inclut déplacements haut, bas, et d'autres directions que nord, sud, est, ouest.

7. 9. keySet

La méthode keySet() de la classe HashMap permet d'accéder à la liste de toutes les clés

contenues dans une HashMap.

12

7. 10. getExitString CCM ?

La méthode getExitString() présentée dans le livre renvoie une description des sorties

possibles d'une pièce :

String returnString = "Sorties :";

o on initialise la variable returnString (de type String) et on y stocke pour

commencer la chaîne de caractère : "Sortie :".

Set<String> keys = exits.keySet();

o on initialise la variable keys (de type Set<String>), i.e. une liste d'éléments de type

String) et on y stocke la liste des clés de la HashMap exits (qui est un attribut de type HashMap de l'objet Room courant) , (exemple de clé : "nord").

for(String exit : keys) {returnString += " " + exit;}

o on déclare une variable locale exit prenant comme valeur la prochaine clé de la HashMap à chaque tour de la boucle for.

o à chaque tour de la boucle, on concatène un espace et la valeur de exit (i.e. une clé de la HashMap) à la chaîne de caractères returnString.

return returnString;

o on finit par retourner une chaine de caractère du type : "Sorties : nord est sud-ouest"

7. 11. getLongDescription

Ajout de la méthode getLongDescription() dans la classe Room (selon livre).

Modification de la méthode printLocationInfo() (selon livre).

7. 14. look

Ajout de la commande "regarder" dans la classe CommandWord.

Ajout de la méthode regarder() dans la classe Game.

Ajout de else if (commandWord.equals("regarder")) {regarder();} dans la classe Game.


13

7. 15. eat

Ajout de la commande "manger" dans la classe CommandWord.

Ajout de la méthode manger() dans la classe Game.

Ajout de else if (commandWord.equals("manger")) {manger();} dans la méthode interpretCommand() de la classe Game.

La commande eat a été cachée du joueur. Elle peut cependant être testée en tapant la commande manger.

7. 16. showAll, showCommands

Implantation des changements décrits dans le livre.

7. 17. changer Game ?

Si l'on ajoute une nouvelle commande, il faudra toujours modifier Game pour créer la méthode

décrivant ce que la commande provoque (comme pour manger() ou regarder() ).


14

7. 18. getCommandsList

Dans la classe CommandWords :

transformation de la méthode showAll() en getCommandsList() comme suit : o public String getCommandsList()

o {

o String vCommandes = "";

o

o for (String command : validCommands) {

o vCommandes += command + " ";

o }

o

o return vCommandes;

o }

Dans la classe Parser :

modification de void showCommands() en String showCommands() : o public String showCommands()

o {

o return commands.getCommandsList();

o }

Dans la classe Game :

modification de la méthode printHelp() : o System.out.println(parser.showCommands() + "\n");

Au lieu de : o parser.showCommands();

15

7. 18. 1. Comparaison avec zuul-better

Point amélioré dans zuul-better et repri dans le projet : Dans la classe Game :

Méthode void printLocationInfo() :

o zuul-better utilise l'instruction System.out.println(currentRoom.getLongDescription());

o au lieu de la méthode void printLocationInfo() qui se résume à cette même seule instruction.

Dans la classe Room : pas de différence. Dans la classe Parser : pas de changement (seule différence : showAll() , cf 7.18).

Dans la classe CommandWords : pas de changement (seule différence : showAll() , cf 7.18). Dans la classe Command : pas de différence.

7. 18. 2. StringBuilder

Dans la classe Room, méthode getExitString() :

Utilisation d'une variable locale de type StringBuilder au lieu de String : o public StringBuilder getExitString()

o {

o StringBuilder vSorties = new StringBuilder("Sorties : ");

o

o Set<String> keys = exits.keySet();

o

o for (String exit : keys) {

o vSorties.append(exit + " ");

o }

o

o return vSorties;

o }

L'utilisation de StringBuilder permet d'utiliser moins de mémoire lors de l'exécution du programme.

16

7. 18. 5. HashMap contenant toutes les Rooms


Ajout d'une HashMap allRooms en attribut : o private HashMap <String,Room> allRooms;

Dans la méthode createRooms(), ajout de toutes les pièces dans allRooms sur le modèle : o allRooms.put("manger" , manger);

7. 18. 6. Comparaison avec zuul-with-images

Modification du projet selon le modèle de zuul-with-images

7. 18. 7. addActionListener() et actionPerformed()

Dans la classe UserInterface :

Dans la méthode createGUI() :

o On initialise la variable entryField de type JtextField (un champ servant à recueillir du texte) comme un champ de 34 caractères :

entryField = new JTextField(34);

o On ajoute la classe UserInterface à la liste des auditeurs de entryField.

C'est-à-dire que lorsqu'un événement se produira sur l'objet entryField (lorsque l'on validera un texte entré dans le champ), la méthode de signature public void

actionPerformed(ActionEvent e), située dans la classe UserInterface, va être invoquée automatiquement.

entryField.addActionListener(this);

Dans la méthode actionPerformed() :

o Cette méthode est appelée automatiquement lorsque entryField est stimulé. o Elle consiste à appeler la méthode processCommand() située en dessous.

Recherches sur le fonctionnement de l'interface ActionListener :

http://stackoverflow.com/questions/2167751/what-addactionlistener-does http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/interagir-avec-son-bouton

http://stackoverflow.com/questions/2167751/what-addactionlistener-does

http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/interagir-avec-son-bouton


17

7. 18. 8. Ajouter au moins un bouton

Ajout des boutons : Manger, Regarder, Nord, Sud, Est, Ouest.


Ajout d'attributs pour chaque bouton, sur le modèle : private Jbutton boutonManger;

Dans la méthode createGUI() :

o Initialisation de chaque bouton, sur le modèle : boutonManger = new Jbutton("Manger");

o Changement du layout manager de la fenêtre myFrame pour un GridLayout d'une ligne et de 2 colonnes :

GridLayout glFrame = new GridLayout(1,2);

glFrame.setHgap(5);

glFrame.setVgap(5);

myFrame.setLayout(glFrame);

o Placement du premier panel (contenant image + affichage) dans la fenêtre myFrame (première colonne) :

myFrame.getContentPane().add(panel);

o Ajout d'un deuxième panel pour y mettre les boutons : JPanel panel2 = new JPanel();

GridLayout glBoutons = new GridLayout(2,3);

glBoutons.setHgap(5);

glBoutons.setVgap(5);

panel2.setLayout(glBoutons);

o Ajout de chaque bouton au deuxième panel créé, sur le modèle : panel2.add(boutonManger);

o Placement du second panel dans la fenêtre myFrame (deuxième colonne) : myFrame.getContentPane().add(panel2);

o Ajout de la classe UserInterface à la liste des auditeurs de chaque bouton, sur le modèle : boutonManger.addActionListener(this);


o Modification de la méthode de façon à différencier les différentes sources ayant déclenché l'événement actionPerformed :

if (e.getSource() == entryField) {processCommand();}

if (e.getSource() == boutonManger) {

engine.interpretCommand("manger");

}

if (e.getSource() == boutonNord) {

engine.interpretCommand("go nord");

}

/* même modèle pour les autres boutons */


18

Recherches sur l'utilisation de layout managers : http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/positionner-son-composant-les-layout-managers

Recherches sur l'utilisation de plusieurs composants au sein d'une même classe : http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/interagir-avec-son-bouton

7. 19. MVC

Le patron Modèle-Vue-Contrôleur est une façon de conception de programme visant à le rendre clair et structuré. Rendant une maintenance ou une amélioration du programme plus aisée. Il s'agit de séparer le traitement et la gestion des données (Modèle), l'affichage des données (Vue), et l'interprétation des commandes de l'utilisateur (Contrôleur). Les 3 types de composants communiquent des ordres et des informations entre eux, mais une modification de la façon de traiter les données (Modèle) n'implique aucune modification nécessaire sur la Vue ou le Contrôleur, par exemple. L'interface graphique Swing de Java est basée sur le patron MVC. L'intérêt de ce patron dans notre projet serait de réduire le couplage et donc de mieux structurer notre programme. Recherches : http://fr.wikipedia.org/wiki/Mod%C3%A8le-Vue-Contr%C3%B4leur http://fr.wikipedia.org/wiki/Swing_%28Java%29

http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/positionner-son-composant-les-layout-managers

http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/positionner-son-composant-les-layout-managers

http://www.siteduzero.com/informatique/tutoriels/apprenez-a-programmer-en-java/interagir-avec-son-bouton

http://fr.wikipedia.org/wiki/Modèle-Vue-Contrôleur

http://fr.wikipedia.org/wiki/Swing_%28Java%29

19

7. 19. 1. zuul-mvc

Création de la classe GameModel : le Modèle du jeu du point de vue du patron MVC.

Attributs : Room currentRoom et HashMap<String,Room> allRooms.

Constructeur GameModel qui lance la méthode createRooms().

Déplacement de la méthode createRooms() dans cette classe.

Création de l'accesseur getCurrentRoom().

Création des accesseurs getWelcomeString(), getGoodByeString(), getHelpString() et getLocationInfo() en reprenant le texte affiché dans ces méthodes.

Création de la classe TextView : la Vue du patron MVC.

Attributs : GameModel gameModel

Constructeur : TextView

Création de la méthode show() avec gui.println(string); au lieu de System.out.println(string);

Création de la méthode update().

Création des méthodes d'affichage printWelcome(), …

** abandon de l’exercice, retour au projet Zuul sans MVC (avant modifications) **

7. 19. 2. Déplacer toutes les images

Création du dossier Images à la racine du jeu (dossier zuul).

Changement du chemin des noms des images associées aux Rooms dans la HashMap sous le

modèle : "Images/salon1.png" au lieu de "salon1.png".

20

7. 20. Item

Création de la classe Item :

2 attributs : String aDescription et double aPoids.

1 constructeur naturel à 2 paramètres.

2 modificateurs setDescription() et setPoids().

2 accesseurs getDescription() et getPoids().

redéfinition de la méthode toString(): cf. exercice 7.21

Dans la classe Room :

Ajout d’un attribut HashMap<String, Item> aItem.

Ajout de la déclaration de la collection d'Items dans le constructeur Room() : o this.aItem = new HashMap<String,Item>();

Modification de getLongDescription() pour afficher la liste des objets présents dans une

Room, grâce à l'appel de la méthode getItemsString() : cf. exercice 7.21

Ajout de la méthode getItemsString() : cf. exercice 7.21

Ajout de la méthode itemDescription() : cf. exercice 7.21

Dans la classe GameEngine,

Création de la méthode createItems() :

Création des Items du jeu sous le modèle : o Item couteau = new Item("un couteau", 0.5);

Association des Items à des salles sous le modèle : o this.allRooms.get("manger").addItem("couteau", couteau);

Dans le constructeur GameEngine() :

o Ajout de l'appel à la méthode createItems().


21

7. 21. item description


Modification de getLongDescription() afin d'afficher les Items contenus dans une Room : o public String getLongDescription()

o {

o return " C'est " + description + "\n"

o + itemDescription()

o + getExitString();

o }

Ajout de itemDescription() afin de modifier la description s'il y a des Items ou non : o public String itemDescription()

o {

o Iterator itemIt = aItem.keySet().iterator();

o

o if (itemIt.hasNext()) {

o return " Il y a " + getItemsString() + "\n";

o }

o

o return "";

o }

Ajout de la méthode getItemsString() permettant d'afficher les Items d'une Room les uns

à la suite des autres (tient compte de la ponctuation en fonction du nombre d'Items) : o public String getItemsString()

o {

o String vI = "";

o Iterator itemIt = aItem.keySet().iterator();

o

o while (itemIt.hasNext()) {

o vI += aItem.get(itemIt.next()).toString();

o if (itemIt.hasNext()) {vI += ", ";}

o }

o

o return vI + ".";

o }

Dans la classe Item :

Redéfinition de la méthode toString() comme suit : o @Override public String toString()

o {

o return this.aDescription + " pesant "

o + this.aPoids + " kg";

o }


22

7. 22. items

Utilisation d'une HashMap associant des clés String (le nom de l'item) à des valeurs Item (l'objet

lui-même). Exemple : ("Couteau", couteau)

7. 22. 1. Justification du choix

Utiliser une HashMap nous permettra de rechercher plus facilement un Item en fonction de son nom, si besoin.

7. 22. 2. Intégrer les Items de son jeu

Ajout de la création du fugu en poudre dans createRooms().

Les Items suivants avaient été ajoutés lors de l'exercice 7.20 :

Couteau

Corps du majordome

Bout de plâtre

Fleurs

Plumeau

Magazine

Parapluie

Tire-bouchon

Télévision

Smoking

Poudre blanche

Cadre photo

Vélo

PC portable

Boîte de cachets


23

7. 23. back

Dans la classe GameEngine :

Ajout d'un attribut Room previousRoom.

Dans la méthode createRooms() :

o Ajout de l'instruction previousRoom = currentRoom;

Dans la méthode goRoom() :

o Ajout de l'instruction previousRoom = currentRoom; afin de se souvenir de la Room actuelle avant de passer à la suivante.

Modification de la méthode interpretCommand() pour prendre back en compte : o else if (commandWord.equals("back"))

o back();

Ajout de la méthode back() : o private void back()

o {

o Room vR = currentRoom;

o currentRoom = previousRoom;

o previousRoom = vR;

o

o gui.println("\n"+currentRoom.getLongDescription()+"\n");

o

o if (currentRoom.getImageName() != null)

o gui.showImage(currentRoom.getImageName());

o }


Ajout du mot "back" dans le tableau de Strings validCommands.

24

7. 26. Stack


Ajout d'un attribut Stack<Room> previousRooms


o création du Stack vide : previousRooms = new Stack<Room>;

o chargement de la première Room du jeu : previousRooms.push(currentRoom);

Dans la méthode goRoom() :

o placement de l'instruction sous le else{ (cas où l'on change effectivement de Room) : previousRooms.push(previousRoom);

Modification du début de la méthode back() : o private void back()

o {

o if (! previousRooms.empty() )

o currentRoom = previousRooms.pop();

o else previousRoom = currentRoom;

o

o gui.println("\n"+currentRoom.getLongDescription()+"\n");

o

o if (currentRoom.getImageName() != null)

o gui.showImage(currentRoom.getImageName());

o }

7. 26. 1. Générer les 2 javadocs

Création d'un fichier .bat contenant les lignes :

SET PATH=%PATH%;"C:\Program Files\Java\jdk1.6.0_33\bin"

cd <chemin vers le dossier du projet zuul>

javadoc -d progdoc -author -version -private -linksource *.java

javadoc -d userdoc -author -version *.java


25

7. 28. 1. test

Dans la classe CommandWord :

Ajout du mot de commande "test" dans le tableau de String en attribut.


Importation des classes : o java.io.IOException o java.io.File o java.util.Scanner

Ajout de la gestion de la commande "test" dans la méthode interpretCommand() : o else if (commandWord.equals("test"))

o test(command);

Ajout de la méthode test() : o private void test(Command pC)

o {

o if (! pC.hasSecondWord()) {

o gui.println("\n Tester quoi ?\n");

o return;

o }

o String fichier = pC.getSecondWord();

o

o try {scan = new Scanner(new File("./"+fichier+".txt"));}

o catch (java.io.FileNotFoundException pException) {

o gui.println("\n Fichier introuvable.\n");}

o

o while (scan.hasNextLine()) {

o String ligne = scan.nextLine();

o interpretCommand(ligne);

o }

o scan.close();

o }

La commande test a été cachée du joueur. Cependant elle peut être testée en tapant la commande tester.


26

7. 28. 2. Création de 2 fichiers de commandes

(test)fonc (test)win

Sert à tester toutes les fonctionnalités du jeu. Teste le chemin le plus court pour gagner.

go

go droite

go est

go est

go sud

go haut

manger

regarder

help

back

back

back

back

back

back

boire

Je m'appelle Léo.

go est

go est

go sud

go bas

go ouest

back

back

back

back

go est

go sud

go haut

go nord

back

back

back

back


27

7. 29. Classe Player

Création de la classe Player :

3 attributs : Room aCurrentRoom, String aName, double aPoidsMax

1 constructeur naturel : o public Player(final String pName, final Room pCurrentRoom,

final double pPoidsMax)

o {

o this.aName = pName;

o this.aCurrentRoom = pCurrentRoom;

o this.aPoidsMax = pPoidsMax;

o }

1 accesseur : getCurrentRoom()

1 modificateur : setCurrentRoom() Dans la classe GameEngine :

Rettrait de l'attribut Room currentRoom

Ajout d'un attribut Player aJoueur

Dans le constructeur GameEngine() :

o ajout de l'appel à la méthode createPlayer()

Ajout de la méthode createPlayer() : o private void createPlayer()

o {

o joueur = new Player("Nanko",

allRooms.get("manger"), 5.0);

o }


o Rettrait de l'instruction currentRoom = manger;

Dans toutes les méthodes de la classe GameEngine :

o remplacement de l'utilisation de l'ancien attribut currentRoom par l'utilisation de l'attribut aCurrentRoom de la classe Player sur l'objet aJoueur :

aJoueur.getCurrentRoom()

aJoueur.setCurrentRoom(previousRooms.pop()) // par

exemple

selon si l'on veut lire l'attribut ou le modifier. Après le lancement du jeu, lancement des 2 fichiers test "(test)fonc" et "(test)win" : le jeu fonctionne aussi bien qu'avant et a gardé toutes ses fonctionnalités.

28

7. 30. & 7. 31. take/drop items

Dans la classe Player :

Ajout d'un attribut HashMap<String, Item> aInventaire o ce choix permettra de désigner les Items plus facilement (commande drop, affichage de

l'inventaire)

Ajout de la création de la HashMap aInventaire dans le constructeur Player().

Ajout d'un accesseur pour la HashMap aInventaire.

Ajout de la méthode putInventory() : o public void putInventory(final String pName, final Item pI)

o {

o this.aInventaire.put(pName, pI);

o }

Ajout de la méthode removeInventory() : o public void removeInventory(final String pName)

o {

o this.aInventaire.remove(pName);

o }


Ajout des mots de commande "prendre" et "poser". Dans la classe Room :

Ajout de l'accesseur getItems() : o public HashMap<String, Item> getItems()

o {

o return this.aInventaire;

o }


Dans la méthode interpretCommand() :

o gestion des mots de commande "prendre" et "poser".


29

Ajout de la méthode take() : o private void take(Command command)

o {

o if (! command.hasSecondWord()) {

o gui.println("\n Prendre quoi ?\n"); return;

o }

o

o String vCommand2 = command.getSecondWord();

o Item vItemRoom =

aJoueur.getCurrentRoom().getItems().get(vCommand2);

o

o if (vItemRoom == null) {

o gui.println("\n Je ne vois pas cet objet ici...\n");

o return;

o }

o else {

o aJoueur.putInventory(vCommand2, vItemRoom);

o aJoueur.getCurrentRoom().getItems().remove(vCommand2);

o gui.println("\n J'ai pris " +

vItemRoom.getDescription() + ".\n" );

o }

o }

Ajout de la méthode drop() : o private void drop(Command command)

o {

o if (! command.hasSecondWord()) {

o gui.println("\n Déposer quoi ?\n"); return;

o }

o

o String vCommand2 = command.getSecondWord();

o Item vItemJoueur = aJoueur.getInventory().get(vCommand2);

o

o if (vItemJoueur == null) {

o gui.println("\n Je n'ai pas ça sur moi...\n");

o return;

o }

o else {

o aJoueur.getCurrentRoom().getItems().put(vCommand2,

o vItemJoueur);

o aJoueur.removeInventory(vCommand2);

o gui.println("\n J'ai déposé " +

vItemJoueur.getDescription() + ".\n");

o }

o }

30

7. 31. 1. Classe ItemList

** incompréhension de l'exercice **

7. 32. Poids max

Dans la classe Player : Ajout de la méthode poidsTotal() :

o public double poidsTotal()

o {

o double vP = 0;

o for (Item vI : this.aInventaire.values()) {

o vP += vI.getPoids();

o }

o return vP;

o }

Ajout de la méthode hasPlaceFor() : o public boolean hasPlaceFor(final Item pI)

o {

o return

(this.poidsTotal() + pI.getPoids()) <= this.aPoidsMax;

o }


Modification du else { de la méthode take() : o private void take(Command command)

o {

o // …

o

o if (vItemRoom == null) {// … }

o else {

o

o if (aJoueur.hasPlaceFor(vItemRoom)) {

o aJoueur.putInventory(vCommand2, vItemRoom);

o aJoueur.getCurrentRoom().getItems().remove(vCommand2);

o gui.println("\n J'ai pris " +

o vItemRoom.getDescription() + ".\n" );

o }

o else {gui.println("\n Je n'ai plus de place pour

ça...\n");}

o }

o }


31

7. 33. inventaire


Ajout du mot de commande "items". Dans la classe GameEngine :

Dans la méthode interpretCommand() : o Ajout de la gestion de la commande "items" :

else if (commandWord.equals("items"))

printInventory();

Ajout de la méthode printInventory() : o private void printInventory()

o {

o gui.println( "\n Inventaire :\n"

o + aJoueur.inventoryString()

o + "\n Poids total : " + aJoueur.poidsTotal() + "\n" );

o }


Ajout de la méthode inventoryString() : o public String inventoryString()

o {

o if (this.aInventaire.isEmpty()) {

o return " Vide...";

o }

o String vS = "";

o for (String vS2 : this.aInventaire.keySet()) {

o vS += " - " + vS2 + " : "

o + this.aInventaire.get(vS2) + "\n";

o }

o return vS;

o }


32

7. 34. magic cookie


Dans la méthode createItems() :

o Création du cookie : Item cookie = new Item("un 'cookie' magique", 0.3);

o Placement du cookie dans une salle : this.allRooms.get("coffre").addItem("cookie", cookie);


o Modification de la gestion du mot de commande "manger" afin de gérer un second mot dans la méthode manger() :

else if (commandWord.equals("manger"))

manger(command);

Dans la méthode manger() : o private void manger(final Command pC)

o {

o if (! pC.hasSecondWord()) {

o gui.println ("\n"

o + " Vous avez mangé, vous n'avez plus faim.\n");

o }

o else {

o if (pC.getSecondWord().equals("cookie")

o && this.aJoueur.hasItem("cookie")) {

o this.aJoueur.setPoidsMax(100.0);

o gui.println(

o "\n Ce cookie était étrange, je me sens plus fort...\n");

o this.aJoueur.removeInventory("cookie");

o }

o else {

o gui.println("\n Où ai-je la tête ?\n");

o }

o }

o }


Ajout du modificateur setPoidsMax() : o public void setPoidsMax(final double pPoids)

o {

o this.aPoidsMax = pPoids;

o }


33

Ajout de la méthode hasItem() :

o public boolean hasItem(final String pS)

o {

o return this.aInventaire.containsKey(pS); }

L'item cookie a été caché du joueur. Cependant il peut être ramassé dans la Room entree (il n'est pas affiché), de

même que le téléporteur.


34

7. 34. 1. Mettre à jour les fichiers de test

(test)fonc (test)win

Sert à tester toutes les fonctionnalités du jeu. Teste le chemin le plus court pour gagner.

go

go droite

prendre couteau

regarder

go est

items

poser couteau

items

regarder

go est

go sud

go bas

manger

manger chocolat

go ouest

go ouest

prendre cookie

back

back

prendre vélo

manger cookie

prendre vélo

items

manger cookie

manger vélo

regarder

help

back

back

back

back

boire

Je m'appelle Léo.

go est

go est

go sud

go bas

go ouest

prendre poudre

back

back

back

back

go est

go sud

go haut

go nord

prendre fugu

back

back

back

back

35

7. 35. & 7. 35. 1. zuul-with-enums-v1

Création de l'enum ComandWord :

• public enum CommandWord

• {

• GO, QUIT, HELP,

• LOOK, EAT,

• BACK,

• TEST,

• TAKE, DROP, ITEMS,

• UNKOWN

• }


• Changement de l'attribut String[] pour une HashMap<String,CommandWord> validCommands.

• Ajout de l'attribut HashMap<CommandWord, String> aValidStrings.

• Ajout du constructeur CommandWord() :

◦ public CommandWords()

◦ {

◦ validCommands = new HashMap<String, CommandWord>();

◦

◦ validCommands.put("go", CommandWord.GO);

◦ validCommands.put("quit", CommandWord.QUIT);

◦ validCommands.put("help", CommandWord.HELP);

◦

◦ validCommands.put("look", CommandWord.LOOK);

◦ validCommands.put("eat", CommandWord.EAT);

◦

◦ validCommands.put("back", CommandWord.BACK);

◦

◦ validCommands.put("test", CommandWord.TEST);

◦

◦ validCommands.put("take", CommandWord.TAKE);

◦ validCommands.put("drop", CommandWord.DROP);

◦ validCommands.put("items", CommandWord.ITEMS);

◦

◦ this.aValidStrings = new HashMap<CommandWord, String>();

◦ rempliValidStrings();

◦ }

36

• Modification de la méthode isCommand() :

◦ public boolean isCommand(String pString)

◦ {

◦ return validCommands.containsKey(pString);

◦ }

• Modification de la boucle for each de la méthode getCommandsList() :

◦ for (String command : validCommands.keySet())

◦ au lieu de for (String command : validCommands)

• Ajout de la méthode getCommandWord() :

◦ public CommandWord getCommandWord(String commandWord)

◦ {

◦ CommandWord command = validCommands.get(commandWord);

◦ if(command != null) {

◦ return command;

◦ }

◦ else {

◦ return CommandWord.UNKNOWN;

◦ }

◦ }

• Ajout de la méthode rempliValidStrings() :

◦ private void rempliValidStrings()

◦ {

◦ Set<Map.Entry<String,CommandWord>> vSet =

◦ this.validCommands.entrySet();

◦

◦ for (Map.Entry<String,CommandWord> vMap : vSet) {

◦ this.aValidStrings.put(vMap.getValue(), vMap.getKey());

◦ }

◦ }

• Ajout de la méthode getWord() :

◦ public String getWord(final CommandWord pC)

◦ {

◦ return this.aValidStrings.get(pC);

◦ }


37

Dans la classe Command :

• L'attribut commandWord est du type CommandWord et non plus String.

• Modicifation du constructeur Command() (premier paramètre CommandWord au lieu de String):

◦ public Command(CommandWord commandWord, String secondWord)

◦ {

◦ this.commandWord = commandWord;

◦ this.secondWord = secondWord;

◦ }

• La méthode getCommandWord() retourne un CommandWord au lieu d'une String.

• Modification de la méthode isUnknown() :

◦ public boolean isUnknown()

◦ {

◦ return (commandWord == CommandWord.UNKNOWN);

◦ }


• Dans la méthode getComand() :

◦ Changement de :

▪ if(commands.isCommand(word1))

▪ return new Command(word1, word2);

▪ else

▪ return new Command(null, word2);

◦ Pour :

▪ return new Command(commands.getCommandWord(word1), word2);


• Dans la méthode interpretCommand() :

▪ String commandWord = command.getCommandWord();

◦ devient :

▪ CommandWord commandWord = command.getCommandWord();

◦ Et :

▪ if (commandWord.equals("help")

▪ printHelp();

◦ devient :

▪ if (commandWord == CommandWord.HELP)

▪ printHelp();


38


Ajout de l'attribut CommandWords aCommandes.

Ajout de la création de l'attribu aCommandes dans le constructeur UserInterface() : o this.aCommandes = new CommandWords();


o Changement des blocs d'instructions sous les if/else if en : else if (e.getSource() == boutonManger) {

engine.interpretCommand(this.aCommandes.getWord(CommandWord.

EAT));

}

o au lieu de : else if (e.getSource() == boutonManger) { engine.interpretCommand("manger"); }

o Pour les commandes du type "go nord", on envoie : (this.aCommandes.getWord(CommandWord.GO) + " nord")

o en paramètre de la méthode getWord().

C'est ici que l'on utilise les méthodes rempliValidCommands() et getWord() de la classe CommandWords, ainsi que l'attribut aValidStrings.

7. 35. 2. switch



o Implémentation du switch pour remplacer la suite de if/else if : switch (commandWord) {

case HELP : printHelp(); break;

case GO : goRoom(command); break;

case QUIT :

if(command.hasSecondWord())

gui.println(" Quit what?");

else

endGame();

break;

case LOOK : regarder(); break;

case EAT : manger(command); break;

case BACK: back(); break;

case TEST: test(command); break;

case TAKE : take(command); break;

case DROP : drop(command); break;

case ITEMS : printInventory(); break;

}

39

7. 37. translate

Grâce aux modifications faites précédemment, il suffit de changer les Strings de la

HashMap<String,CommandWord> validCommands de la classe CommandWords.

Ceci marche pour les commandes à entrer ainsi que les boutons. Une traduction des commandes du jeu est ainsi facilitée.

7. 38. help

Changer la String "help" en "aide" fonctionne.

Mais le message de bienvenue dit toujours « Tapez "help" si vous êtes perdus.»

Pour cela, on change la partie de la méthode printWelcome() de la classe GameEngine

comme suit : o gui.println( "Tapez '"

o + this.aCommandes.getWord(CommandWord.HELP)

o + "' si vous êtes perdu.\n" );

On déclare aussi un attribut CommandWord aCommandes, que l’on créer dans le constructeur GameEngine().

7. 41. 1. zuul-with-enums-v2

Dans l’enum CommandWord :

Ajout des valeurs de type String sur le modèle : o GO("go"), QUIT("quit"), HELP("help");

Ajout du constructeur CommandWord() et de la method toString() comme décrits dans le

projet zuul-with-enums-v2. Dans la classe CommandWords :

Dans le constructeur CommandWords() :

o Remplacement de la suite de .put() par la boucle for comme décrite dans zuul-with-enums-v2.

40

7. 42. & 7. 42. 1. time limit (en temps réel)


Ajout de la méthode time() : o public void time()

o {

o long vStartTime = System.currentTimeMillis();

o long vCurrentTime = 0;

o

o while (vCurrentTime - vStartTime < 60000) {

o vCurrentTime = System.currentTimeMillis();

o }

o // 60 000 millisecondes = 1 minute : fait pour test

o engine.gameOver("time");

o }


Ajout de la méthode gameOver() : o public void gameOver(final String vS)

o {

o if (vS.equals("time")) {

o gui.println(" Désolé, vous n'avez pas résolu le crime à

temps...\n");

o gui.enable(false);

o }

o }

Cette méthode doit être changée. En effet, l'appel de la méthode time() dans le constructeur de Game fait que l'objet Game ne finit jamais de se créer avant la fin de la boucle while. Cette erreur a été aperçue à l'occasion de l'exercice 59 (applet) : l'objet Game n'étant pas créé avant la fin du timer, il était indisponible jusqu'alors (et donc le jeu n'était pas accessible). Voici la nouvelle méthode utilisée alors. Du code a été emprunté à un groupe d'élèves d'ESIEE Paris : Aymeric KOEPPEL, Sébastien HU, Frédéric NGUYEN, Justine BOUGNOL (projet "Death Ception"). Création de la classe Clock :

1 attribut int aTime

1 constructeur naturel.

1 méthode decrement() : o public void decrement() o { o this.aTime--; o }

1 accesseur getTime().

1 méthode booléenne pour connaître l'état du compteur : public boolean isOver()

{

return this.aTime <= 0;

}

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


41


Ajout d'un attribut statique et d'un attribut d'instance : o private static final int TIME = 3600; // temps en secondes

o private Clock aClock;

Création de l'objet Clock dans le constructeur GameEngine() : o this.aClock = new Clock(TIME);

1 accesseur getClock() qui renvoie l'objet Clock. Dans la classe UserInterface :

Ajout d'un attribut javax.swing.Timer aTimer

Création de l'objet Timer, puis démarrage de l'activité du Timer, dans la méthode createGUI() : o this.aTimer = new Timer(1000, this);

o this.aTimer.start();

Ajout de la prise en compte de l'activité du Timer dans la méthode actionPerformed() : o public void actionPerformed(ActionEvent e)

o {

o if (e.getSource() == this.aTimer) {

o this.engine.getClock().decrement();

o if (this.engine.getClock().isOver()){

o this.aTimer.stop();

o engine.gameOver("time");

o }

o }

o //...

o }

7. 43. trap door



o Suppression d’une instruction créant une sortie de la Room entree : //entree.setExit("nord" , salon);

o Ainsi, on peut entrer dans cette Room par cette porte mais on ne peut pas utiliser la même porte pour en sortir.


42

7. 44. beamer

Création de la classe Beamer, héritant de la classe Item :

2 attributs : boolean aCharged et Room aRoomCharge

2 constructeurs : un par défaut et un naturel : o /* par défaut */ o public Beamer() o { o this("", 0.0); o } o /* naturel */ o public Beamer(final String pDesc, final double pPoids) o { o super(pDesc, pPoids); o this.aCharged = false; o }

2 accesseurs : boolean isCharged(final Room pRoom) et Room getRoomTP()

2 modificateurs : void charge() et void discharge() Ajout des enums CHARGE("charge"), TELEPORT("teleport") dans l’enum CommandWord.


Ajout de la gestion des cas CHARGE et TELEPORT dans le switch de la méthode interpretCommand() :

o case CHARGE : chargeTP(command,this.aJoueur.getCurrentRoom());

o break;

o case TELEPORT : useTP(command); break;

Ajout de la method chargeTP() : o private void chargeTP(final Command pC, final Room pR)

o {

o // Charger quel TP ?

o String vNomTP = pC.getSecondWord();

o Item vBeamerAsItem =

o this.aJoueur.getInventory().get(vNomTP);

o Beamer vBeamer = new Beamer();

o

o // TP dans inventaire ?

o if (vBeamerAsItem == null) {

o gui.println(" Je n'ai pas cet objet sur moi...\n");

o return;

o }

o


43

o // TP est bien un Beamer ?

o try {

o vBeamer = (Beamer)vBeamerAsItem;

o }

o catch (java.lang.ClassCastException pE) {

o gui.println(" Je ne peux pas charger ça...\n");

o return;

o }

o

o // Charger TP :

o vBeamer.charge(this.aJoueur.getCurrentRoom());

o gui.println(" Le téléporteur est chargé.\n");

o

o }

Ajout de la méthode useTP() : o private void useTP(final Command pC)

o {

o // Utiliser quel TP ?

o String vNomTP = pC.getSecondWord();

o Item vBeamerAsItem =

this.aJoueur.getInventory().get(vNomTP);

o Beamer vBeamer = new Beamer();

o

o // TP dans inventaire ?

o if (vBeamerAsItem == null) {

o gui.println(" Je n'ai pas cet objet sur moi...\n");

o return;

o }

o

o // TP est bien un Beamer ?

o try {

o vBeamer = (Beamer)vBeamerAsItem;

o }

o catch (java.lang.ClassCastException pE) {

o gui.println(" Je ne peux pas charger ça...\n");

o return;

o }

o

o // Utiliser TP si TP chargé

o if (vBeamer.isCharged()) {

o gui.println(" Je me suis téléporté.\n");

o this.aJoueur.setCurrentRoom(vBeamer.getRoomTP());

o gui.println("\n" +

aJoueur.getCurrentRoom().getLongDescription() + "\n");

o if(aJoueur.getCurrentRoom().getImageName() != null)

o

gui.showImage(aJoueur.getCurrentRoom().getImageName());

o }


44

o else {

o gui.println(" Le téléporteur n'est pas chargé...\n");

o return;

o }

o

o // Décharger TP :

o vBeamer.discharge();

o }

Les commandes charge et teleport ont été cachée du joueur. Cependant elles peuvent être testées en tapant

charger et teleporter. Un téléporteur peut être trouvé dans la Room entree.

7. 45. 1. Mettre à jour les fichiers de test

(test)fonc

go

go droite

take couteau

look

go sud

take téléporteur

go nord

go est

items

drop couteau

items

look

go est

charge téléporteur

go sud

go bas

eat

eat chocolat

go ouest

go ouest

take cookie

back

back

take vélo

eat cookie

take vélo

items

eat cookie

eat vélo

look

help

back

back

back

back

teleport téléporteur

drink

Je m'appelle Léo.

Le fichier (test)win permettant d'arrive le plus vite possible à la fin du jeu ne nécessite pas d'utiliser un téléporteur.

45

7. 46. TransporterRoom Ajout de la classe TransporterRoom héritant de la classe Room :

1 attribut : static RoomRandomizer aRoomRand;

1 constructeur : o public TransporterRoom(final String pDescription, final String pImage)

o {

o super(pDescription, pImage);

o }

1 modificateur appelé automatiquement dans GameEngine.createRooms() pour "compléter" l'objet : o public void setAllRooms(final HashMap<String, Room> pAllRooms)

o {

o this.aRoomRand = new RoomRandomizer(pAllRooms);

o }

1 redéfinition de getExit() : o @Override

o public Room getExit(final String pDirection)

o {

o return this.aRoomRand.findRandomRoom();

o }

Ajout de la classe RoomRandomizer :

2 attributs : o static HashMap<String, Room> allRooms;

o static ArrayList<Room> aRoomsInArray;

1 constructeur : o public RoomRandomizer(final HashMap<String, Room> pAllRooms)

o {

o this.allRooms = pAllRooms;

o this.aRoomsInArray = new ArrayList<Room>();

o fillArrayList();

o }

1 méthode fillArrayList() : o private void fillArrayList()

o {

o for (String vR : this.allRooms.keySet()) {

o this.aRoomsInArray.add(this.allRooms.get(vR));

o }

o }

la méthode findRandomRoom() : o public Room findRandomRoom()

o {

o Random vRandomizer = new Random();

o int vI = vRandomizer.nextInt(this.aRoomsInArray.size());

o

o return this.aRoomsInArray.get(vI);

o }

46

Les attributs static des classes TransporterRoom et RoomRandomizer permettent de n'avoir à les initialiser qu'une fois depuis la classe GameEngine (appel des méthodes setAllRooms() et RoomRandomizer() avec l'attribut HashMap<String, Room> allRooms en paramètre), quelque soit le nombre de TransporterRooms. Dans la classe GameEngine :


o Modification de la création de la Room entree : entree = new TransporterRoom("l'entrée, mieux vaut attendre

l'arrivée de la police." , "Images/entree1.jpg");

o Même modification pour la Room laverie afin de tester la gestion de plusieurs

TransporterRoom (modification annulée après le test positif) : il suffit de cette modification pour ajouter de nouvelles TransporterRoom en plus de entree.

o Ajout d'une instruction à la fin de la méthode, après que la HashMap<String, Room> allRooms ait été remplie avec toutes les Rooms créées :

((TransporterRoom)entree).setAllRooms(this.allRooms);

o Cette modification n'a pas a être répétée pour d'autres TransporterRoom grâce au statut static des attributs des classes TransporterRoom et RoomRandomizer.

7. 46. 1. alea

** incompréhension de l'exercice **

7. 46. 2. L'héritage

L'héritage a déjà été utilisé pour la classe Beamer.

7. 46. 3. Javadoc

Commentaires javadoc des classes mis à jour.

7. 46. 3. Regénérer les javadocs

Javadocs progdoc et userdoc regénérées et mises à jour sur le site du jeu.


47

7. 47. abstract Command Modification de la classe Command :

en une classe abstraite

ajout de la méthode abstraite public abstract void execute(Player player);

Modification du constructeur : o public Command()

o {

o this.commandWord = null;

o this.secondWord = null;

o }

Ajout de 2 modificateurs : setCommandWord() et setSecondWord(). Création d'une classe héritant de Command par commande :

Chaque classe est de la forme suivante : o public class GoCommand extends Command

o {

o public GoCommand()

o {

o }

o

o @Override

o public void execute(final Player player)

o {

o if (this.hasSecondWord()) {

o String vDirection = this.getSecondWord();

o player.walk(vDirection);

o }

o else {

o player.getGUI().println("\n Où ?\n");

o }

o }

o }

Où la méthode execute() remplace chaque méthode spécifique à sa commande de la classe

GameEngine.

Les appels dans les méthodes de GameEngine …

… deviennent dans execute() :

au paramètre command this

à l'attribut aJoueur paramètre player

à gui.println() player.getGUI().println()

à une autre méthode de GameEngine player.getGUI().getEngine().nomDeLaMethode()

à l'attribut parser de GameEngine player.getGUI().getEngine().getParser()

Ces changements ont nécessité l'ajout d'un attribut de type UserInterface à la classe Player, ce qui a

nécessité la modification de son constructeur, et donc l'ordre de lancement des méthodes dans les classes Game et GameEngine (afin de ne créer le joueur qu'une fois que le GUI avait été créé). De même, les accesseurs getGUI(), getEngine() et getParser(), situés respectivement dans les classes Player, UserInterface et GameEngine, ont été ajouté lors de cet exercice.

48


Les méthodes goRoom(), endGame(), chargeTP(), regarder(), printHelp(),

useTP(), drop(), take(), printInventory(), eat(), test() et back() ont été

déplacée dans les méthodes execute() de leurs classes respectives (GoCommand, QuitCommand, …)

Modification de interpretCommand() : o public void interpretCommand(String commandLine)

o {

o gui.println(commandLine);

o Command command = parser.getCommand(commandLine);

o

o if(command == null) {

o gui.println("\n Quoi ?\n");

o return;

o }

o else {

o command.execute(this.aJoueur);

o }

o }

Dans l'enum CommandWord :

Modification de la structure des éléments de l'enum : o chaque CommandWord admet un attribut String (associé à la commande à taper par le joueur) et

un attribut Command (associé à la sous-classe de Command qui correspond à l'élément). o le modèle de déclaration : GO("go", new GoCommand())

Modification du constructeur en conséquence : o CommandWord(final String commandString, final Command pCommand)

o {

o this.commandString = commandString;

o this.aCommand = pCommand;

o }

Ajout d'un accesseur : o public Command toCommand()

o {

o return this.aCommand;

o }


Ajout d'un attribut HashMap<String, Command> aCommands

Modification du constructeur : o public CommandWords()

o {

o this.validCommands = new HashMap<String, CommandWord>();

o for(CommandWord command : CommandWord.values()) {

o if(command != CommandWord.UNKNOWN) {

o validCommands.put(command.toString(), command);

o }

o }

o this.aValidStrings = new HashMap<CommandWord, String>();

o rempliValidStrings();

o

o

o

49

o

o this.aCommands = new HashMap<String, Command>();

o for (CommandWord vCW : CommandWord.values()) {

o if (vCW != CommandWord.UNKNOWN) {

o this.aCommands.put(vCW.toString(), vCW.toCommand());

o }

o }

o }

Ajout de la méthode get() décrite dans zuul-even-better : o public Command get(String word)

o {

o return (Command)this.aCommands.get(word);

o }


Dans la méthode getCommand() : o Modification de la fin de la méthode :

if (commands.get(word1) == null) {

return null;

}

Command vCommand = commands.get(word1);

vCommand.setCommandWord(commands.getCommandWord(word1));

if(vCommand.getCommandWord() != null) {

vCommand.setSecondWord(word2);

}

return vCommand;

o Au lieu de : return new Command(commands.getCommandWord(word1), word2);

7. 47. 1. Paquetages Création de 4 paquetages :

Nom du paquetage

pkg_game pkg_commands pkg_rooms pkg_items

Contient les classes

GameEngine

UserInterface

Player

Parser

CommandWord

CommandWords

Command

GoCommand

QuitCommand

…

Room

TransporterRoom

RoomRandomizer

Item

Beamer

50

Pour indiquer qu'une classe appartient à un package, on note en première ligne de la classe : o package pkg_items; // exemple pour une classe du package pkg_items

Lorsqu'une classe utilise une classe ne se trouvant pas dans le même package qu'elle, on importe la classe manquante (voire le package entier si l'on utilise toutes les classes s'y trouvant) comme ceci :

o import pkg_game.Player; // exemple dans la classe Command

ou encore : o import pkg_rooms.*; // exemple dans la classe GameEngine

Il était nécessaire de placer la classe Player dans un package autre que le package par défaut car l'importation de classes du package par défaut dans des classes de sous-packages et interdit depuis la version 4 de Java.

7. 48. Character Création d'un package pkg_characters :

Création d'une classe abstraite Character : o 3 attributs :

private String aName;

private Room aCurrentRoom;

private HashMap<Integer, String> aDialogues;

o 1 constructeur : public Character(final String pName, final Room pCurrentRoom)

{

this.aName = pName;

this.aCurrentRoom = pCurrentRoom;

this.aDialogues = new HashMap<Integer,String>();

this.setDialogues();

}

o 1 modificateur de l'attribut Room en prévision des MovingCharacter : setRoom().

o 1 modificateurs permettant d'ajouter une entrée à l'attribut HashMap<Integer,String> : public void addDialogue(final int pKey, final String pText)

{

this.aDialogues.put(pKey, pText);

}

o 1 méthode abstraite qui commandera l'initialisation des dialogues de chaque Character : public abstract void setDialogues();

o 2 accesseurs : getRoom() et getDialogues() qui renvoient directement les attributs concernés.

o 1 méthode abstraite qui renverra un certain dialogue tiré de la HashMap<Integer,String> en fonction d'actions du joueur :

public abstract String getDialogue(final Player pPlayer);

51

o 1 méthode appelée par la commande talk, mettant en forme le dialogue : public String talk(final Player pPlayer)

{

return "<blockquote>" + this + " : \"" +

this.getDialogue(pPlayer) + "\"</blockquote>";

}

o La redéfinition de la méthode toString(), pour obtenir le nom du Character en violet : @Override public String toString()

{

return "" + this.aName + "";

}

o 1 méthode abstraite qui sera appelée par la commande accuse : public abstract String accuse(final Player pPlayer);

Création de 4 classes héritant de Character (1 sous-classe par personnage non-mouvant du jeu) sur le

modèle : public class DaymeCharacter extends pkg_characters.Character

o le constructeur : public DaymeCharacter(final Room pRoom)

{

super("Dayme", pRoom);

}

o la redéfinition de la méthode setDialogues() : @Override

public void setDialogues()

{

this.addDialogue(0, "J'étais dans la buanderie au moment

où j'ai entendu Shinichi tomber...");

this.addDialogue(1, "Oui, je savais que Shinichi testait

toujours le vin avant de le servir.");

// …

}

o la redéfinition de la méthode getDialogue() : @Override

public String getDialogue(final Player pPlayer)

{

// 0. Sait pas pour le vin, pas testament, pas journal,

pas fugu

if (!pPlayer.getAction("kenji0") &&

!pPlayer.getAction("kenji2") && !pPlayer.getAction("meidin4")

&& !pPlayer.getAction("meidin5")) {

return this.getDialogues().get(0);

}

// 1. Sait pour vin, pas testament, pas journal, pas fugu

if (!pPlayer.getAction("dayme1") ||

(!pPlayer.getAction("kenji2") && !pPlayer.getAction("meidin4")

&& !pPlayer.getAction("meidin5"))) {

pPlayer.setActionTrue("dayme1");

return this.getDialogues().get(1);

}

52

// …

}

o la redéfinition de la méthode accuse() : @Override

public String accuse(final Player pPlayer)

{

// Le joueur sait pour le vin, pas testament, pas journal,

pas fugu

if (pPlayer.getAction("dayme1") &&



return "C'est vrai que je savais que Shinichi goûtait

le vin avant de le servir, mais ce n'est pas moi ! Nous étions

amis.";

}

// Le joueur connait testament, pas journal, pas fugu :

if (pPlayer.getAction("kenji3") &&

!pPlayer.getAction("meidin4") &&

!pPlayer.getAction("meidin5")) {

return "Je n'étais pas concernée par l'héritage, je

n'avais aucune raison de tuer Shinichi.";

}

// …

}


Ajout d'un atribut HashMap<String,pkg_characters.Character> aCharacters

Ajout de la méthode createCharacters() : o public void createCharacters()

o {

o /* déclarations des characters */

o pkg_characters.Character vMouri, vKenji, vDayme, vMeidin,

vChaina;

o

o /* création des characters */

o vMouri = new

pkg_characters.MouriCharacter(this.allRooms.get("cuisine"),

aJoueur);

o vKenji = new

pkg_characters.KenjiCharacter(this.allRooms.get("salon"));

o vDayme = new

pkg_characters.DaymeCharacter(this.allRooms.get("salon"));

o vMeidin = new

pkg_characters.MeidinCharacter(this.allRooms.get("salon"));

o vChaina = new

pkg_characters.ChainaCharacter(this.allRooms.get("salon"));

o

o /* placement des characters dans l'attribut HashMap */

o this.aCharacters = new HashMap<String,

pkg_characters.Character>();

o

o this.aCharacters.put("Mouri", vMouri);

o this.aCharacters.put("Kenji", vKenji);

o this.aCharacters.put("Dayme", vDayme);

53

o this.aCharacters.put("Meidin", vMeidin);

o this.aCharacters.put("Chaina", vChaina);

o

o /* placement des characters dans leurs Rooms */

o this.updateCharsRooms();

o }

Ajout de la méthode updateCharsRooms() : o public void updateCharsRooms()

o {

o for (String vS : this.allRooms.keySet()) { // pour chaque Room

du jeu

o this.allRooms.get(vS).getCharacters().clear(); // effacer

les Characters

o }

o

o for (String vS : this.aCharacters.keySet()) { // puis les

remettre au bon endroit

o this.aCharacters.get(vS).getRoom().putCharacter(vS,

this.aCharacters.get(vS));

o }

o }

Ajout d'un accesseur getCharacters() qui renvoie l'attribut aCharacters tel quel. Dans la classe Game :

Dans le constructeur Game() :

o Ajout de l'appel à la méthode engine.createCharacters() après l'appel de engine.createPlayer().


Ajout d'un attribut HashMap<String, Boolean> aActions

Ajout dans le constructeur Player() : o this.aActions = new HashMap<String,Boolean>();

o this.setActions();

Ajout de la méthode setActions() : o private void setActions()

o {

o this.addAction("mouri1");

o this.addAction("mouri2");

o // …

o }

Ajout de la méthode addAction() : o private void addAction(final String pKey)

o {

o this.aActions.put(pKey,false);

o }

Ajout de la méthode setActionTrue() : o public void setActionTrue(final String pKey)

o {

o this.aActions.put(pKey,true);

o }

54

Ajout de la méthode getAction() : o public boolean getAction(final String pKey)

o {

o return this.aActions.get(pKey);

o }

Les Characters changent de dialogues en fonction de l'avancement du joueur dans l'enquête. L'avancement du joueur est déterminé grâce à l'attribut HashMap<String,Boolean> du Player où chaque Map correspond à un point clé de l'enquête. Une valeur false signifie que le point clé n'a pas été atteint, tandis que les valeurs deviennent true lorsque le point clé associé a été atteint.

Exemples de points clés vérifiés : la présence de l'item journal dans l'inventaire du joueur ; le fait que le joueur ait

inspecté l'item testament ; le fait que le joueur ait obtenu une certaine information en parlant à un certain personnage.

Parenthèse : passage du log du jeu en HTML

Les String destinées à être affichées dans le log de la fenêtre du jeu sont maintenant écrites en HTML afin de mettre le texte en forme plus facilement. Pour cela, on a conservé l'attribut JTextArea log et ajouté un attribut JEditorPane aLog qui récupère le contenu du JTextArea et qui s'affiche à la place. Recherches :

http://stackoverflow.com/questions/5915061/html-in-jtextarea-of-jeditorpane-jtextpane

o Pour remplacer le JTextArea par un JEditorPane. o Exemple : la méthode println() de UserInterface devient :

public void println(String text)

{

log.append(text + " ");

aLog.setText("<html><head></head><body>"

+ log.getText()

+ "</body></html>");

aLog.setCaretPosition(aLog.getDocument().getLength());

}

o La méthode retenue est différente. Seul a été retenu l'usage de la méthode setText(). http://stackoverflow.com/questions/12231750/jtextfield-together-with-html-tags

et http://docs.oracle.com/javase/7/docs/api/javax/swing/JEditorPane.html#setContentType%28java.lang.String%29

o Dans la méthode createGUI(), on indique au JEditorPane aLog de gérer le HTML : aLog.setContentType("text/html");

o Après avoir importé le HTMLEditorKit dans UserInterface : javax.swing.text.html.HTMLEditorKit;

http://www.dynamicdrive.com/forums/showthread.php?18899-HTML-Tags-in-JTextPane-JFrame

o pour savoir qu'il faut faire précéder les guillemets d'un antislash pour les afficher au sein d'une

String : "" . http://stackoverflow.com/questions/3693543/hyperlink-in-jeditorpane

o pour ouvrir les liens cliquables dans le navigateur par défaut du système où le jeu est exécuté (emprunt de code décrit dans la classe UserInterface).

http://stackoverflow.com/questions/5915061/html-in-jtextarea-of-jeditorpane-jtextpane

http://stackoverflow.com/questions/12231750/jtextfield-together-with-html-tags

http://docs.oracle.com/javase/7/docs/api/javax/swing/JEditorPane.html#setContentType%28java.lang.String%29

http://www.dynamicdrive.com/forums/showthread.php?18899-HTML-Tags-in-JTextPane-JFrame

http://stackoverflow.com/questions/3693543/hyperlink-in-jeditorpane

55

7. 48. MovingCharacter Dans le package pkg_characters :

Ajout d'une classe abstraite MovingCharacter héritant de Character : public abstract class MovingCharacter extends

pkg_characters.Character

o avec 1 constructeur : public MovingCharacter(final String pName, final Room

pCurrentRoom)

{

super(pName, pCurrentRoom);

}

o 1 méthode move() : public void move(final Room pNewRoom, final Player pPlayer,

final boolean print)

{

this.setRoom(pNewRoom);

if (print) {

pPlayer.getGUI().println("<blockquote>" + this + " est

sortie de la pièce.</blockquote>");

}

}

o 1 méthode abstraite moveCondition() décrivant les conditions pour faire bouger un

MovingCharacter : public abstract void moveCondition(final Player pPlayer);

Ajout d'une classe héritant de MovingCharacter par personnage mouvant, sous la forme : public class MouriCharacter extends

pkg_characters.MovingCharacter

o avec 1 constructeur : public MouriCharacter(final Room pRoom, final Player pPlayer)

{

super("Mouri", pRoom);

}

o la redéfinition de setDialogues() comme pour les autres Characters.

o la redéfinition de getDialogue() comme pour les autres Characters. o la redéfinition de accuse() comme pour les autres Characters. o la redéfinition de la méthode moveCondition() :

@Override

public void moveCondition(final Player pPlayer)

{

if (this.getRoom() ==

pPlayer.getGUI().getEngine().getAllRooms().get("cuisine")) {

if (pPlayer.getAction("mouri1") &&



this.move(pPlayer.getGUI().getEngine().getAllRooms().get("vin"

), pPlayer, true);

56

pPlayer.getGUI().getEngine().updateCharsRooms();

pPlayer.setActionTrue("mouri2");

}

if (pPlayer.getAction("kenji2") ||

pPlayer.getAction("meidin4") || pPlayer.getAction("meidin5"))

{

this.move(pPlayer.getGUI().getEngine().getAllRooms().get("salo

n"), pPlayer, false);



}

}

else if (this.getRoom() ==

pPlayer.getGUI().getEngine().getAllRooms().get("vin")) {

if (pPlayer.getAction("mouri3")) {


n"), pPlayer, true);



}

if (pPlayer.getAction("kenji2") ||

pPlayer.getAction("meidin4") || pPlayer.getAction("meidin5"))

{


n"), pPlayer, false);



}

}

}

Dans le package pkg_commands :

Ajout de l'enum TALK("talk", new TalkCommand()) dans CommandWord

Ajout de la classe TalkCommand : o Redéfinition de execute() :

@Override

public void execute(final Player player)

{

// A quel personnage ?

if (!this.hasSecondWord()) {

player.getGUI().println("<blockquote>À qui dois-je

parler ?</blockquote>");

return;

}

String vName = this.getSecondWord();

pkg_characters.Character vPerso =

player.getCurrentRoom().getCharacters().get(vName);

57

// Personnage présent dans la pièce ?

if (vPerso == null) {

player.getGUI().println("<blockquote>Je ne vois pas

cette personne ici...</blockquote>");

return;

}

// Parler

player.getGUI().println( vPerso.talk(player) );

// Si le perso est un Moving Character :

if (vPerso instanceof pkg_characters.MovingCharacter) {

((MovingCharacter)vPerso).moveCondition(player);

}

}

Ajout de l'enum ACCUSE("accuse", new AccuseCommand()) dans CommandWord.

Ajout de la classe AccuseCommand :

o avec 2 attributs statics : private static int NBaccuse = 0;

private static final int MAXaccuse = 4;

o redéfinition de execute() : @Override


{

// Si pas de personnage


player.getGUI().println("<blockquote>Il me reste "

+ (this.MAXaccuse-this.NBaccuse) + "

accusations.</blockquote>");

return;

}

String vName = this.getSecondWord();

pkg_characters.Character vPerso =

player.getCurrentRoom().getCharacters().get(vName);

// Personnage présent ?

if (vPerso == null) {

player.getGUI().println("<blockquote>Je ne vois pas

cette personne ici...</blockquote>");

return;

}

// Accuser

this.NBaccuse++;

player.getGUI().println("<blockquote>" + vName + " : \"" +

vPerso.accuse(player) + "\"</blockquote>");

/* si accusation fail + compteur accusations épuisé */

if (!player.getAction("accuseSuccess") && this.NBaccuse ==

this.MAXaccuse) {

58

player.getGUI().getEngine().gameOver("accuse lim");

return;

}

/* si accusation fail mais compteur non épuisé */

else if (!player.getAction("accuseSuccess")) {

player.getGUI().println("<blockquote>Je peux encore

porter " + (this.MAXaccuse-this.NBaccuse)

+ " accusations avant de perdre toute

crédibilité.</blockquote>");

}

else if (player.getAction("accuseSuccess")) {

player.getGUI().getEngine().gameOver("win");

}

}

7. 49. 2. Incorporer les élémenst restants du scénario Ajout de la classe WrapItem héritant de Item :

2 nouveaux attributs : o private Item aItemContenu;

o private String aNameItem;


2 accesseurs getItem() et getName().

1 modificateur deleteItem().

Cette classe décrit un WrapItem contenant lui-même un Item, il s'agit d'utiliser la commande inspect sur le WrapItem situé dans la Room courante ; le joueur obtient ainsi l'Item contenu dans le WrapItem.

Ajout de la classe NoteItem héritant de Item :

1 nouvel attribut : String aNote


1 accesseur getNote().

Cette classe décrit un NoteItem sur lequel est écrit une note, il s'agit d'utiliser la commande inspect sur le NoteItem situé dans l'inventaire du joueur ; le contenu de la note est alors affichée.

Ajout de la commande inspect :

@Override


{

if (! this.hasSecondWord()) { // si objet non précisé

player.getGUI().println("<blockquote>Inspecter quoi

?</blockquote>"); return;

}

String vCommand2 = this.getSecondWord(); // nom de l'objet

Item vItemRoom = player.getCurrentRoom().getItems().get(vCommand2);

// objet dans la Room

Item vItemInv = player.getInventory().get(vCommand2); // objet dans

inventaire joueur

59

if (vItemRoom == null) { // si objet non présent dans Room :

// =-=-= Si objet non présent dans inventaire :

if (vItemInv == null) {

player.getGUI().println("<blockquote>Je ne vois pas cet

objet...</blockquote>");

return;

}

// =-=-= Si objet lisible :

else if (vItemInv instanceof pkg_items.NoteItem) {

this.read(vItemInv, player, vCommand2);

}

// =-=-= Si objet fouillable :

else if (vItemInv instanceof pkg_items.WrapItem) {

this.dig(vItemInv, player, vCommand2);

}

else { // si objet ni lisible, ni fouillable :

player.getGUI().println("<blockquote>La fouille n'a rien

donné...</blockquote>"); return;

}

}

else { // =-=-= Si objet présent dans Room :

// =-=-= Si objet lisible :

if (vItemRoom instanceof pkg_items.NoteItem) {

this.read(vItemRoom, player, vCommand2);

}

// =-=-= Si objet fouillable :

else if (vItemRoom instanceof pkg_items.WrapItem) {

this.dig(vItemRoom, player, vCommand2);

}

else { // si objet ni lisible, ni fouillable :

player.getGUI().println("<blockquote>La fouille n'a rien

donné...</blockquote>"); return;

}

}

}

On peut ainsi ajouter 3 items au jeu :

le testament : un NoteItem donné par le personnage KenjiCharacter.

le journal : un NoteItem trouvé dans la chambre des jumeaux.

la corbeille : un WrapItem contenant l'Item fugu créé auparavant. Ajout de 3 nouveaux Characters :

KenjiCharacter

MeidinCharacter

ChainaCharacter

60

Ajout de la commande clues qui affiche la liste des indices découverts par le joueur :

Redéfinition de execute() : o @Override

o public void execute(final Player player)

o {

o player.getGUI().print("<blockquote>Indices : " +

player.getIndicesString()+ "</blockquote>" );

o }

Avec la méthode getIndicesString() de Player : o public String getIndicesString()

o {

o StringBuilder vIndices = new StringBuilder("");

o

o // vin

o if (this.aActions.get("mouri1") || this.aActions.get("kenji0")

|| this.aActions.get("dayme1") || this.aActions.get("meidin1") ||

this.aActions.get("chaina1")) {

o vIndices.append("<h3 align=\"center\" color=\"#FFB727\"

color=\"#FFB727\">Le vin :</h3>");

o }

o

o if (this.aActions.get("mouri1")) {

o vIndices.append(" - Le vin que buvait Shinichi

moussait sur le sol. ");

o }

o // …

o

o // testament

o if (this.aActions.get("kenji3") || this.aActions.get("dayme2")

|| this.aActions.get("meidin2") || this.aActions.get("chaina2")) {

o vIndices.append("<h3 align=\"center\" color=\"#FFB727\">Le

testament de Kenji Hikaru :</h3>");

o }

o

o if (this.aActions.get("kenji3")) {

o vIndices.append(" - Kenji avait désigné Meïdin, Chaïna et

Shinichi comme ses seuls héritiers. ");

o }

o // …

o

o // journal

o if (this.aActions.get("meidin4")) { // "meidin44" ==>

"meidin4"


journal intime :</h3>");

o }

o

o if (this.aActions.get("meidin4") &&

!this.aActions.get("meidin44")) {

o vIndices.append(" - L'un des jumeaux tient un

journal où il a juré la mort de son père, 3 jours plus

tôt. ");

o }

o //…

61

o

o // fugu

o if (this.aActions.get("meidin5")) { // "meidin55" ==>

"meidin5"


fugu :</h3>");

o }

o

o if (this.aActions.get("meidin5")) {

o vIndices.append(" - J'ai trouvé une épine de fugu

dans la corbeille de la chambre des jumeaux. ");

o }

o // …

o

o if (vIndices.toString().equals("")) {

o vIndices.append("Aucun...");

o }

o return vIndices.toString();

o }

7. 50. maximum

La signature de la méthode de la classe java.lang.Math calculant le maximum entre 2 entiers est : o public static int max(int a, int b)

7. 51. static

Les méthodes de la classe Math sont static car elle consistent à faire subir des traitements mathématiques à des paramètres. Elles n'ont pas besoin de stocker des valeurs dans des attributs.

De plus, de cette façon, on peut accéder à des opérations mathématiques plus avancées que les opérations de base en Java sans avoir besoin de créer un "objet Math".

7. 52. currentTimeMillis

Classe Test : o public class Test

o {

o public static void timeToCount()

o {

o long vStartTime = System.currentTimeMillis();

o for (int i = 1 ; i <= 100 ; i++) {}

o long vEndTime = System.currentTimeMillis();

o System.out.println("Time to count from 1 to 100 : " +

(vEndTime-vStartTime) + " milliseconds.");

o }

o }


62

7. 53. main()

Création de la méthode main() dans la classe Game : o public static void main(String[] pArgs)

o {

o Game vGame = new Game();

o }

7. 54. sans BlueJ

Création d'un fichier Jar avec la classe Game comme classe principale.

Ouvrir le fichier Jar ainsi créé lance le jeu.

7. 56. test static

Une méthode d'instance peut appeler une méthode static car une méthode static peut être appelée

n'importe quand (pas de restriction telle que le fait de devoir être appelée sur une instance de sa classe).

Une méthode static peut appeler une méthode d'instance, à condition de d'abord stocker, dans une

variable locale, un objet de la classe où la méthode d'instance que l'on souhaite appeler à été définie.

Une méthode static peut appeler une autre méthode static car les méthodes static n'ont pas de

contrainte à respecter pour pouvoir être appelées. Voici les tests effectués pour vérifier ces réponses : Création de nouvelles méthodes dans la classe Test créée lors de l'exercice 7.52 :

Une méthode d'instance appelant une méthode static : o public void instance1() o { o System.out.println("This is an instance method, let's call a static method :"); o timeToCount(); o }

Une méthode static appelant la méthode d'instance après avoir créé un objet Test : o public static void static3() o { o System.out.println("This is a static method, let's call an instance method :"); o Test vTest = new Test(); o vTest.instance1(); o }


63

Une méthode static appelant la première méthode static : o public static void static2() o { o System.out.println("This is a static method, let's call an other static method : "); o timeToCount(); o }

7. 57. numberOfInstances()

Pour compter le nombre de fois qu'une classe a été instanciée, il faut créer un attribut de classe : o private static int aCounterOfInstances = 0;

Puis ajouter une instruction au constructeur par défaut (et aux éventuels autres constructeurs définis, afin de s'assurer que chaque constructeur de la classe pouvant être appelé n'oublie pas d'incrémenter l'attribut de classe) :

o public Test()

o {

o aCounterOfInstances++;

o }

Enfin, on défini la méthode static numberOfInstances() : o public static int numberOfInstances()

o {

o return aCounterOfInstances;

o }

On a ainsi un attribut de classe qui s'incrémente à chaque instanciation de la classe Test, et une méthode static qui nous retourne le nombre de fois que la classe Test a été instancée.

58. & 58. 1. Exécuter un fichier Jar par un Terminal

Création d'un fichier Jar (cf. exercice 7.54) nommé nanko.jar, sur le bureau.

Test sur Windows : o Dans un terminal, changement de répertoire pour atteindre le répertoire où se trouve le fichier Jar :

cd C:\Users\LeoD\Desktop

o Ouverture du fichier Jar : java –jar nanko.jar

o Le jeu se lance correctement depuis le terminal.

Test sur Linux : o Memes commandes :

cd /home/Desktop

java –jar nanko.jar

o Le jeu se lance aussi correctement.


64

59. JApplet

Héritage de la classe JApplet pour la classe Game : o public class Game extends javax.swing.JApplet

Dans la classe UserInterface : o Ajout de la méthode killFrame() :

public void killFrame()

{

myFrame.setVisible(false);

myFrame.dispose();

System.exit(0);

}

o Dans la méthode createGUI() : myFrame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {killFrame();}

});

o au lieu de myFrame.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {System.exit(0);}

});

Sources :

http://www.esiee.fr/~bureaud/Unites/Zuul/applette.htm

59. 1. Test de l'applet

Test de l'intégration de l'applet en HTML sur la page web personnelle ESIEE du projet (fonctionne) : o http://www.esiee.fr/~dupontl/zuul/jouer.html

60. & 60. 1. Application & Applet

Le fichier Jar généré à l'exercice 7.59 peut être exécuté en tant qu'application, ainsi qu'en tant qu'applet sur un site web.

60. 3. Commentaires Javadoc

Commentaires Javadocs ajoutés pour chaque méthode du projet.

http://www.esiee.fr/~bureaud/Unites/Zuul/applette.htm

http://www.esiee.fr/~dupontl/zuul/jouer.html

65

60. 4. Générer les Javadocs

Génération des Javadocs progdoc et userdoc du projet avec de nouvelles commandes : o javadoc -d progdoc -author -version -private -linksource pkg_*

*.java

o javadoc -d userdoc -author -version pkg_* *.java

Mise à jour des Javadocs sur le site web du projet.

61. Sauvegarde de l'état du jeu Liste des éléments à sauvegarder afin de retrouver le jeu exactement dans le même état après avoir rechargé une sauvegarde :

Player : o le poids maximal de l'inventaire (peut changer avec cookie magique) o la Room courante o les Rooms visitées (pour la commande retour) o les actions du joueur o l'inventaire du joueur

GameEngine : o le temps restant o le contenu des Rooms (items uniquement)

UserInterface :

o le log du jeu

MovingCharacters : o appeler la méthode moveCondition() suffit à mettre à jour la position des MovingCharacters car

cette méthode s'appuie sur les actions du joueur, qui ont déjà été sauvegardées. Implémentation de la sauvegarde (version 1, la sauvegarde ne marche pas lorsque le projet est archivé dans un Jar) (version 2, cette version crée un fichier sur le disque dur de la machine exécutant le programme, code emprunté à "Boris the Spider" à la page : http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive) : Création de la commande SaveCommand, dont la redéfinition de execute() :

@Override public void execute(final Player player)

{

// === Dans quel fichier === //


player.getGUI().println("<blockquote>Veuillez spécifier un nom

de sauvegarde.</blockquote>");

return;

}

String vNomFichier = this.getSecondWord();

http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive

66

/* création du dossier de sauvegarde */

File vDossier = new File(System.getProperty("user.home"),

"NankoSaves");

if (!vDossier.exists() && !vDossier.mkdirs()) {

player.getGUI().println("<blockquote>Impossible de créer le

dossier de sauvegarde.</blockquote>");

return;

}

/* création du fichier de sauvegarde */

PrintWriter vPW;

try {vPW = new PrintWriter("./saves/" + vNomFichier + ".txt");} //

try {vPW = new PrintWriter(new File(vDossier, vNomFichier+".txt"));}

catch (final IOException pExp) {

player.getGUI().println("<blockquote>Impossible de créer le

fichier.</blockquote>");

return;

}

// === Ecritures dans le fichier === //

/* sauvegarde des attributs de Player */

vPW.println(player.toString());

/* sauvegarde des attributs de GameEngine */

vPW.println(player.getGUI().getEngine().toString()+"~log~:");

/* sauvegarde du log */

vPW.println(player.getGUI().getLog());

// === Fermeture du fichier === //

vPW.close();

}


Ajout de la méthode toString() : o @Override public String toString()

o {

o char vSeparateurDecimalSystem = new

java.text.DecimalFormatSymbols().getDecimalSeparator();

o Double vPoids = this.aPoidsMax;

o String vPoidsString =

(vPoids.toString()).replace('.',vSeparateurDecimalSystem);

o

o return "player-poids:"+vPoidsString

o +":player-room:"+this.aCurrentRoom.getName()

o +":player-rooms:"+this.previousRoomsToString()+"|"

o +":player-actions:"+this.actionsToString()+"|"

o +":player-items:"+this.inventaireToString()+"|"

o +":";

o }

67

Ajout de la méthode previousRoomsToString() : o public String previousRoomsToString()

o {

o /* copie de la Stack */

o Stack<Room> vStack = new Stack<Room>();

o vStack.addAll(this.previousRooms);

o Stack<Room> vStack2 = new Stack<Room>();

o while (!vStack.empty()) {

o vStack2.push(vStack.pop());

o }

o /* mise en forme de la String */

o StringBuilder vS = new StringBuilder("");

o while (!vStack2.empty()) {

o vS.append(vStack2.pop().getName()+":");

o }

o return vS.toString();

o }

Ajout de la méthode actionsToString() : o public String actionsToString()

o {

o StringBuilder vSreturn = new StringBuilder("");

o for (String vS : this.aActions.keySet()) {

o if (this.aActions.get(vS)) {

o vSreturn.append(vS+":");

o }

o }

o return vSreturn.toString();

o }

Ajout de la méthode inventaireToString() : o public String inventaireToString()

o {


o for (String vS : this.aInventaire.keySet()) {

o vSreturn.append(vS+":");

o }


o }


Ajout de la méthode toString() : o @Override public String toString()

o {

o return ":engine-clock:"+this.getClock().getTime()+":\n"

o +":engine-rooms-

items:"+this.allRoomsItemsToString()+"|:";

o }


68

Ajout de la méthode allRoomsItemsToString() : o public String allRoomsItemsToString()

o {


o for (String vS : this.allRooms.keySet()) {

o vSreturn.append("-

"+vS+":"+this.allRooms.get(vS).itemsToString()+"&:");

o }


o }


Ajout de la méthode getLog() : o public String getLog()

o {

o return this.log.getText();

o }

Recherches :

http://www.esiee.fr/~bureaud/Unites/In101/Cours/fichiersJava.htm o Pour écrire dans un fichier texte.

http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive o Pour créer un dossier et un fichier en dehors de l'archive Jar du jeu.

http://www.velocityreviews.com/forums/t138890-decimal-separator-and-double-valueof.html o Pour connaître le séparateur décimal de la machine exécutant el programme : o char vSeparateurDecimalSystem = new

java.text.DecimalFormatSymbols().getDecimalSeparator();

http://www.developpez.net/forums/showthread.php?t=37485 o Pour convertir un type primitif double en une String.

http://stackoverflow.com/questions/4323599/best-way-to-parsedouble-with-comma-as-decimal-separator o Pour connaître la méthode replaceAll() de la classe String (la méthode replace() a été

retenue). o (vPoids.toString()).replace('.',vSeparateurDecimalSystem);

http://stackoverflow.com/questions/7919836/how-do-i-copy-a-stack-in-java o Pour savoir comment faire une copie d'une Stack.

62. Recharge de l'état du jeu De même que pour l'exercice 61 : (version 1, la sauvegarde ne marche pas lorsque le projet est archivé dans un Jar) (version 2, cette version crée un fichier sur le disque dur de la machine exécutant le programme, code emprunté à "Boris the Spider" à la page : http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive) : Création de la commande LoadCommand, dont la redéfinition de execute() :

@Override


{

UserInterface vGUI = player.getGUI();

GameEngine vEngine = player.getGUI().getEngine();

http://www.esiee.fr/~bureaud/Unites/In101/Cours/fichiersJava.htm


http://www.velocityreviews.com/forums/t138890-decimal-separator-and-double-valueof.html

http://www.developpez.net/forums/showthread.php?t=37485

http://stackoverflow.com/questions/4323599/best-way-to-parsedouble-with-comma-as-decimal-separator

http://stackoverflow.com/questions/7919836/how-do-i-copy-a-stack-in-java


69

// === Quel fichier === //


vGUI.println("<blockquote>Veuillez spécifier un nom de

sauvegarde.</blockquote>");

return;

}

String vNomFichier = this.getSecondWord();

/* recherche du dossier de sauvegarde */

File vDossier = new File(System.getProperty("user.home"),

"NankoSaves");

if (!vDossier.exists()) {

vGUI.println("<blockquote>Dossier de sauvegarde

introuvable.</blockquote>");

return;

}

/* recherche du fichier de sauvegarde */

Scanner vSc;

try {vSc = new Scanner(new File("./saves/"+vNomFichier+".txt"));} //

try {vSc = new Scanner(new File(vDossier, vNomFichier + ".txt"));}

catch (final java.io.FileNotFoundException pExp) {

vGUI.println("<blockquote>Sauvegarde

introuvable.</blockquote>");

return;

}

vSc.useDelimiter(":");

// === Lecture du fichier === //

while (vSc.hasNext()) {

String vS = vSc.next();

if (vS.equals("\n")) {}

/* attributs de Player, sauf currentRoom (cf fin du while) */

else if (vS.equals("player-poids"))

{player.setPoidsMax(vSc.nextDouble());}

else if (vS.equals("player-rooms")) {

String vS2 = vSc.next() ;

Stack<Room> vStack = new Stack<Room>();

while (!vS2.equals("|") && vSc.hasNext()) {

vStack.addElement(vEngine.getAllRooms().get(vS2));

vS2 = vSc.next();

}

player.setPreviousRooms(vStack);

}

else if (vS.equals("player-actions")) {

String vS2 = vSc.next();


70

player.setActionTrue(vS2);

vS2 = vSc.next();

}

}

else if (vS.equals("player-items")) {



player.getInventory().put(vS2,

vEngine.getAllItems().get(vS2));

vS2 = vSc.next();

}

}

/* attributs de GameEngine */

else if (vS.equals("engine-clock")) {

vEngine.getClock().setTime(vSc.nextInt());

}

else if (vS.equals("engine-rooms-items")) {



if (vS2.charAt(0) == '-') { // ex: -cuisine

String vRoomName = vS2.replaceFirst("-",""); //

enlever le tiret -

Room vRoom = vEngine.getAllRooms().get(vRoomName); //

trouver la Room (ex: cuisine)

vRoom.clearItems(); // effacer les items de la room

String vS4 = vSc.next(); // item (ex: couteau)

while (!vS4.equals("&") && vSc.hasNext()) {

vRoom.addItem(vS4,

vEngine.getAllItems().get(vS4)); // ajouter l'item à la room

vS4 = vSc.next(); // item suivant

}

}

vS2 = vSc.next(); // room suivante

}

}

else if (vS.equals("~log~")) {

StringBuilder vLog = new StringBuilder("");

while (vSc.hasNextLine()) {

vLog.append(vSc.nextLine());

}

vGUI.setLog(vLog.toString());

}

/* Room courante du Joueur (en dernier pour affichage des infos

de la Room à jour) */

else if (vS.equals("player-room"))

{player.setCurrentRoom(vEngine.getAllRooms().get(vSc.next()));}

}


71

/* MovingCharacters */

((MovingCharacter)vEngine.getCharacters().get("Mouri")).moveCondition(pla

yer, false);

// === Fermeture du fichier === //

vSc.close();

} Dans la classe UserInterface :

Ajout de la méthode setLog() : o public void setLog(final String pLog)

o {

o this.log.setText("");

o this.print(pLog);

o }

Recherches :

http://www.esiee.fr/~bureaud/Unites/In101/Cours/fichiersJava.htm o Pour lire un fichier texte.

http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive o Pour créer un dossier et un fichier en dehors de l'archive Jar du jeu.

http://www.developpez.net/forums/d449654/java/general-java/langage/pb-scanner-java-util-inputmismatchexception/

o Pour connaître la méthode useDelimiter() de la classe Scanner.

http://www.esiee.fr/~bureaud/Unites/In101/Cours/fichiersJava.htm





72

63. 3 scénarios de test

(test)win

- scénario gagnant -

(test)fonc

- toutes les commandes -

(test)rooms

- toutes les rooms -

aller nord

aller est

aller est

aller sud

aller haut

aller nord

prendre journal

inspecter journal

inspecter corbeille

retour

retour

retour

retour

parler Kenji

parler Meidin

parler Meidin

parler Meidin

parler Meidin

accuser Meidin

aller nord

aide

aller est

aller sud

prendre cookie

manger cookie

prendre téléporteur

retour

charger téléporteur

aller sud

aller sud

teleporter téléporteur

poser téléporteur

inventaire

parler Kenji

aller est

aller sud

aller haut

aller nord

inspecter corbeille

sauvegarder saveTest

indices

continuer saveTest

regarder

accuser

retour

retour

retour

retour

accuser Chaina

aller nord

aller est

aller sud

retour

aller est

aller sud

aller bas

aller ouest

aller ouest

retour

retour

retour

aller haut

aller nord-ouest

retour

aller nord

retour

aller nord-est

retour

aller sud-ouest

retour

aller sud

63. 1. Tout recompiler

Tous les paquetages ont été recompilés. Sans aucun warning.

63. 2. & 63. 1. Compléter le scénario

Le scénario a été entièrement complété lors de l'exercice 7.49.2.

Les situations gagnantes et perdantes y ont été rendues fonctionnelles.


73

63. 4. Regénérer les Javadocs

Javadocs progdoc et userdoc regénérées et mises à jour sur la page web du jeu.


74

Emprunts de code

À Aymeric KOEPPEL, Sébastien HU, Frédéric NGUYEN et Justine BOUGNOL (étudiants ESIEE Paris, projet 2012 : "Death Ception", site web : http://www.esiee.fr/~hse/ ) :

o Exercice 7.42.1 (temps réel) : Classe Clock (originellement Countdown), partie Timer de la classe UserInterface.

À Michael MROZEK (http://stackoverflow.com/questions/3693543/hyperlink-in-jeditorpane) : o Pour utiliser les liens hypertextes dans le JEditorPane, voici le code emprunté, présent

dans la classe UserInterface, méthode createGUI() : aLog.addHyperlinkListener(new HyperlinkListener() {

public void hyperlinkUpdate(HyperlinkEvent e) {

if (e.getEventType() ==

HyperlinkEvent.EventType.ACTIVATED) {

// Launching browser :

if (Desktop.isDesktopSupported()) {

try

{Desktop.getDesktop().browse(e.getURL().toURI());}

catch (final java.net.URISyntaxException exp)

{}

catch (final java.io.IOException exp) {}

}

}

}

});

o Les blocs try-catch ont été rajoutés pour gérer les exceptions.

À Boris the Spider (http://stackoverflow.com/questions/16497666/create-write-read-a-text-file-external-to-the-jar-archive) :

o Exercices 61 et 62 (sauvegarde/recharge du jeu) : pour la création d'un dossier externe au Jar du jeu avant de créer un fichier dedans.

o Voici le code original emprunté : final File folder = new

File(System.getProperty("user.home"), "gamesaves");

if(!folder.exists() && !folder.mkDirs()) {

//failed to create the folder, probably exit

throw new RuntimeException("Failed to create save

directory.");

}

final File myFile = new File(folder, vNomFichier +

".txt");

final PrintWriter pw = new PrintWriter(myFile);

o Les modifications sont en vert dans les exercices 61 et 62.

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

http://stackoverflow.com/questions/3693543/hyperlink-in-jeditorpane



rapport de projet zuul - perso.esiee.frdupontl/zuul/rapport.pdf · rapport de projet zuul a3p...

Documents