Lire le chapitre 7 jusqu'à l'exercice 7.1 non inclus.
Faire l'exercice 7.1 (découverte zuul-bad) :
Pour un premier contact, parcourir la
documentation
puis les
sources
du projet zuul-bad
(ne pas chercher à comprendre le code source pour l'instant).
Pour pouvoir l'utiliser puis en modifier la programmation, il faut enregistrer ce fichier
zuul-bad.jar,
puis utiliser (juste pour la première fois) "Ouvrir non-BlueJ ..." dans BlueJ ;
ensuite, il suffira d'utiliser "Ouvrir un projet ..." .
(This project is called ‘bad’ because its
implementation contains some bad design decisions, and we want to leave no doubt
that this should not be used as an example of good programming practice!)
Execute and explore the application. The project comment gives you some information about
how to run it.
While exploring the application, answer the following questions
(and write the answers into the report) :
- What does this application do?
- What commands does the game accept?
- What does each command do?
- How many rooms are in the scenario?
Draw a map of the existing rooms.
|
Faire l'exercice 7.2 (rôle des classes) :
After you know what the whole application does, try to find out what
each individual class does.
Write down for each class the purpose of the class.
You need to look at the source code to do this. Note that you might not (and need not)
understand all of the source code. Often, reading through comments and looking at
method headers is enough.
|
Exercice 7.2.1 :
Lire la documentation de la classe Scanner et comprendre
comment elle est utilisée dans zuul-bad.
Rédiger les explications dans le Rapport.
Apprentissage :
Scanner
Lire le chapitre 7 jusqu'à l'exercice 7.3 non inclus.
Faire l'exercice 7.3 (scénario libre) :
Design your own game scenario. Do this away from the computer.
Do not think about implementation, classes, or even programming in general.
Just think about inventing an interesting game. This could be done with a group of people.
The game can be anything that has as its base structure a player moving through different
locations. Here are some examples:
- You are a white blood cell traveling through the body in search of viruses to attack…
- You are lost in a shopping mall and must find the exit ...
- You are a mole in its burrow and you cannot remember where you stored your food
reserves before winter ...
- You are an adventurer who searches through a dungeon full of monsters and other characters ...
- You are from the bomb squad and must find and defuse a bomb before it goes off ...
Make sure that your game has a goal (so that it has an end and the player can ‘win’).
Try to think of many things to make the game interesting (trap doors, magic items,
characters that help you only if you feed them, time limits, whatever you like). Let your
imagination run wild.
At this stage, do not worry about how to implement these things.
|
D'autres idées de projets figurent dans cette
liste de thèmes.
Exercice 7.3.1 :
Écrire dans le Rapport
les informations demandées ci-dessous.
-------------------------------------------------------------------
Rapport :
Titre provisoire + lien page web
(PR*02 2009/2010 αβ)
I.A) Auteurs
I.B) Theme (voir liste des etudiants)
I.C) Resume du scenario (complet)
I.D) Plan (complet, avec indication de la partie "reduit")
I.E) Scenario detaille (complet, avec indication de la partie "reduit"))
I.F) Detail des lieux, items, personnages
I.G) Situations gagnantes et perdantes
I.H) Eventuellement enigmes, mini-jeux, combats, etc.
II. Reponses aux exercices (autres que I.)
III, IV, etc... : tout ce que vous voulez en plus
-------------------------------------------------------------------
Ce fichier sera complété ou modifié au fur et à mesure
de l'avancement du projet.
À cette étape :
1) Ne pas se limiter et imaginer le jeu idéalement
souhaité à la fin du projet.
Pour donner une idée des fonctionnalités attendues d'ici à la fin du projet,
voici un petit résumé du minimum qui sera demandé :
gérer des déplacements dans au moins 4 directions plus haut et bas ;
pouvoir ramasser/porter/reposer des objets avec une certaine limite de poids/prix qui peut-être
augmentée en mangeant un "gateau magique" ;
charger/utiliser un "téléporteur" pour vous ramener dans un lieu précédemment
visité ;
prévoir une pièce qui lorsqu'on la quitte vous téléporte de façon
aléatoire dans un autre lieu du jeu ;
gérer des "passages" entre lieux empruntables dans un seul sens et/ou fermés à clé ;
gérer des personnages fixes ou mobiles, pouvant dialoguer ou non, pouvant échanger des objets ou non ;
...
2) Ne pas se focaliser sur la future interface avec l'utilisateur
(graphique, souris, clavier) mais s'en tenir au scénario.
Exercice 7.3.2 :
Dessiner un plan du jeu
faisant bien apparaître la géographie
des lieux, le nom des lieux, ainsi que les passages possibles entre-eux;
l'incorporer au Rapport
(Ce peut être un plan dessiné à la main, puis scanné.).
Exercice 7.3.3 optionnel :
Délimiter un sous-ensemble du scénario
détaillé à l'exercice précédent en essayant
de ne pas dépasser 5 ou 6 lieux et 2 ou 3 items.
Cela permettra de ne pas avoir trop de modifications à effectuer
à chaque "remaniement" du code source.
Rendre disponible ce "sous-scénario" sur la page web du projet,
accompagné de son plan (ou du plan du 7.3.1 faisant apparaître
clairement les éléments retenus pour le 7.3.3).
Lire le chapitre 7 jusqu'à l'exercice 7.4 non inclus.
Faire l'exercice 7.4 (zuul-v1, rooms, exits,
en se basant sur la version délimitée au 7.3.3) :
Open the zuul-bad project, and save it under a different name (e.g. zuul-v4).
This is the project you will use to make improvements and modifications throughout this chapter.
You can leave off the -bad suffix, since it will soon (hopefully) not be that bad anymore.
As a first step, change the createRooms method in the Game class to create the
rooms and exits you invented for your game. Test!
|
Lire le chapitre 7 jusqu'à l'exercice 7.5 non inclus.
Faire l'exercice 7.5 (printLocationInfo).
A partir de cet exercice, noter dans le Rapport qui fait quoi
(ou quelle paire est plus particulièrement chargée de quoi).
|
Implement and use a separate printLocationInfo method in your
project, as discussed in this section. Test your changes.
|
Lire le chapitre 7 jusqu'à l'exercice 7.6 non inclus.
Faire l'exercice 7.6 (getExit)
|
Make the changes we have described to the Room and Game classes.
|
Faire l'exercice 7.7 (getExitString).
|
Make a similar change to the printLocationInfo method of Game
so that the details of the exits are now prepared by the Room
rather than the Game. Define a method in Room with the
following signature public String getExitString().
|
Lire le chapitre 7 jusqu'à l'exercice 7.8 non inclus.
Faire l'exercice 7.8 (HashMap, setExit).
N'y aurait-il pas une méthode inutile désormais ?
Exercice 7.8.1 :
Ajouter dans le scénario
(si ce n'est pas déjà le cas)
et dans son jeu au moins un lieu
sur un plan différent des autres lieux et nécessitant
donc un déplacement vertical.
Attention ! Une sortie est une destination, pas un nom de lieu (Room) !
Mettre à jour le Rapport.
Lire le chapitre 7 jusqu'à l'exercice 7.9 non inclus.
Faire les exercices (sauf la rédaction dans le Rapport)
7.9 (keySet)
et 7.10 (getExitString CCM).
Apprentissage :
HashMap et Set
Lire le chapitre 7 jusqu'à l'exercice 7.11 non inclus.
Faire l'exercice 7.11 (getLongDescription).
Faire les exercices 7.12 (diagramme objet)
et 7.13 (go => changement).
(object est à prendre au sens d'objet Java)
Lire le chapitre 7 jusqu'à l'exercice 7.14 non inclus.
Faire les exercices 7.14 (look)
et 7.15 (eat).
Lire le chapitre 7 jusqu'à l'exercice 7.16 non inclus.
Faire l'exercice 7.16 (showAll, showCommands).
Apprentissage : for ( typeElement element : tableau )
Faire l'exercice 7.17 (changer Game ?).
Exercice 7.17.1 :
S'assurer que chaque classe et chaque méthode
ont leur commentaire javadoc, sinon compléter.
Exercice 7.17.2 :
Générer la javadoc grâce à BlueJ et
la rendre accessible par un lien sur la page web du jeu.
... à faire avant le TP1.
Lire le chapitre 7 jusqu'à l'exercice 7.18 non inclus.
Faire l'exercice 7.18 (getCommandList).
Exercice 7.18.1 :
Comparer son projet à celui-ci
(gestion des sorties et des descriptions) :
documentation et
sources du projet zuul-better;
corriger si besoin est, sans régression bien sûr !
(notamment, pas d'itérateur quand on peut utiliser une boucle for each) ;
tout recompiler : il ne doit y avoir aucun warning.
Exercice 7.18.2 :
Étudier la documentation de StringBuilder
pour comprendre son utilité et
l'intégrer à son jeu, notamment dans
Room.getExitString().
Apprentissage: StringBuilder, im/mutable
Exercice 7.18.3 :
Commencer à chercher une image différente
pour chaque Room. Ce peut être une photo, une image de synthèse,
un dessin scanné, ...
Exercice 7.18.4 :
Décider du titre du jeu, et l'incorporer
dans le message de bienvenue du jeu,
dans le Rapport,
et dans la page web.
Exercice 7.18.5 :
Pour avoir accès aux objets Room
depuis n'importe quelle classe, créer une HashMap
contenant toutes les Room (associées à leur nom).
Il suffira alors de la passer en paramètre, en cas de besoin.
Exercice 7.18.6 :
Étudier le projet suivant
(Game, GameEngine, UserInterface) :
documentation et
sources
du projet zuul-with-images
pour comprendre son fonctionnement global et intégrer dans son jeu
(sans régression bien sûr ! notamment en ce qui concerne la généricité
des collections : il ne doit subsister aucun warning/avertissement !)
cette nouvelle conception qui permettra d'opter éventuellement par la suite
pour une interface graphique plus élaborée
(voir rubrique Plus de technique).
Exercice 7.18.7 :
Décrire le fonctionnement de addActionListener()
et actionPerformed() dans UserInterface.
Exercice 7.18.8 :
Ajouter au moins un bouton qui déclenche une des commandes du jeu.
Apprentissage : ActionListener, addActionListener() et actionPerformed()
Faire l'exercice 7.19 (MVC).
Exercice 7.19.1 optionnel :
Après avoir fait l'exercice 7.19,
étudier le projet suivant
(Game, GameModel, TextView) :
documentation et
sources du projet zuul-mvc
pour comprendre son fonctionnement et intégrer dans
la version "with-images" que l'on vient de créer cette
nouvelle conception plus proche de l'architecture MVC qui permettra
par exemple de faire cohabiter 2 observateurs (texte + graphique).
Exercice 7.19.2 :
Déplacer toutes les images dans un répertoire Images
à créer à la racine du projet.
Incorporer dans le jeu une image différente
pour chaque Room. S'il en manque, fabriquer une "image de mot"
pour afficher simplement le nom du lieu
(voir rubrique Plus de technique).
Lire le chapitre 7 jusqu'à l'exercice 7.20 non inclus.
Faire l'exercice 7.20 dans son jeu (Item);
il est possible de remplacer le poids de chaque item par un prix,
ou même de prévoir les deux !
Faire l'exercice 7.21 (item description
sauf Explain in writing);
"information about" est à prendre au sens de "toutes les informations sur".
Il est également possible de prévoir une
longDescription pour chaque Item ; voir quand il serait
intéressant de l'utiliser.
Lire le chapitre 7 jusqu'à l'exercice 7.22 non inclus.
Faire l'exercice 7.22 (items).
Exercice 7.22.1 optionnel :
Justifier par écrit
le choix du type de collection utilisé à l'exercice 7.22.
Exercice 7.22.2 :
Intégrer les objets (items) de son jeu
(au moins ceux du sous-scénario).
Lire le chapitre 7 jusqu'à l'exercice 7.23 non inclus.
Faire l'exercice 7.23 (back).
Faire les exercices (sauf
la rédaction pour le Rapport)
7.24 (back test) et 7.25 (back back).
Modifier son jeu s'il n'a pas le comportement désiré.
Faire l'exercice 7.26 (Stack).
La commande back fonctionne-t-elle si l'on est revenu
au point de départ du jeu ?
Modifier son jeu s'il n'a pas le comportement désiré.
Apprentissage: Stack, push(), pop(), empty(), peek()
Exercice 7.26.1 :
Générer les 2 javadoc du projet en utilisant :
javadoc -d docprog -author -version -private -linksource *.java
javadoc -d docuser -author -version *.java
à partir de la ligne de commande, et rendre ces documentations
accessibles par un lien sur la page web du jeu.
... à faire avant le TP2.
Lire le chapitre 7 jusqu'à l'exercice 7.27 non inclus.
Faire les exercices 7.27 (tests)
et 7.28 (automatisation des tests).
Exercice 7.28.1 :
Créer une nouvelle commande test
acceptant un second mot représentant un nom de fichier, et
exécutant toutes les commandes lues dans ce fichier de texte.
Apprentissage : lecture de fichiers de texte, hasNext(), next(), exceptions
(voir rubrique Plus de technique)
Exercice 7.28.2 :
Créer 2 fichiers de commandes :
1) parcours idéal pour gagner 2) exploration de toutes les possibilités du jeu
Exercice 7.28.3 optionnel :
Prévoir des mécanismes
permettant de spécifier ce qui est attendu et de vérifier
que c'est bien le cas. Par exemple, "est-on au bon endroit ?" ou
"tel item est-il présent ?"
Lire le chapitre 7 jusqu'à l'exercice 7.29 non inclus.
Faire les exercices 7.29 (Player),
7.30 (take, drop), et 7.31 (porter items).
Remarque sur le 7.29 : c'est la classe GameEngine et non Game qui contient trop de code.
Exercice 7.31.1 :
Créer une nouvelle classe ItemList
pour gérer une liste d'items et ainsi mutualiser la gestion des items
qui se retrouvait dupliquée dans Room et dans Player.
Faire les exercices 7.32 (poids max),
7.33 (inventaire), et 7.34 (magic cookie)
(une adaptation est nécessaire
si la notion de prix est utilisée).
Exercice 7.34.1 :
Mettre à jour les fichiers de test, notamment celui
qui doit tester le jeu le plus exhaustivement possible.
Lire le chapitre 7 jusqu'à l'exercice 7.35 non inclus.
Apprentissage : enum, values()
Faire l'exercice 7.35 à l'aide de la
documentation et des
sources du projet zuul-with-enums-v1.
Exercice 7.35.1 :
Incorporer cette nouvelle conception dans son jeu
(sans régression, bien sûr).
Exercice 7.35.2 :
En s'inspirant de processCommand() de la classe Game dans zuul-with-enums-v1,
remplacer dans interpreteCommand() de la classe GameEngine dans son jeu la suite de
if else par un
switch
(autorisé sur un type énuméré !) ;
tout recompiler : il ne doit y avoir aucun warning.
Ne pas faire l'exercice 7.36 (hors projet) .
Faire les exercices 7.37 (translate) et
7.38 (help).
Ne pas faire l'exercice 7.39 (hors projet) .
Lire le chapitre 7 jusqu'à l'exercice 7.40 non inclus.
Faire les exercices 7.40 (look) et 7.41 (help)
à l'aide de la
documentation et des
sources du projet zuul-with-enums-v2.
Exercice 7.41.1 :
Incorporer cette nouvelle conception dans son jeu
(sans régression, bien sûr, notamment pour le switch) ;
tout recompiler : il ne doit y avoir aucun warning.
Exercice 7.41.2 :
Après avoir lu de la documentation sur les interfaces graphiques en Java
(voir rubrique Plus de technique),
décider et dessiner (éventuellement à la main)
l'interface graphique définitive qu'aura le jeu.
Exercice 7.41.3 :
Re-générer les 2 javadoc du projet comme à l'exercice 7.26.1,
et les mettre à jour sur la page web du jeu.
... à faire avant le TP3.