Wall-J: the Space Cleaner

Condition de rendu

Cahier des charges

1. Les tableaux
   Le jeu est composé de plusieurs tableaux, comme Angry Birds. Le but est de ranger les détritus d'un tableau pour avoir le droit de passer au tableau suivant. Si un des détritus n'est pas rangé, alors le tableau n'est pas fini : l'utilisateur doit recommmencer et résoudre le tableau avant de pouvoir passer au tableau suivant.
   Chaque tableau est spécifié dans un fichier au format texte dans un fichier level.txt : level0.txt pour le premier niveau, level1.txt pour le second, etc. Un utilisateur pourra aussi créer ses propres niveaux.
   Voici un exemple de tableau très simple.

             WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
             W                                                        W
             T                                                        T
             T                                                        T
             T                                                        T
             T             G                                          T
             T             G                                          T
             T             G                                          T
             T                                                        T
             T                                                        T
             T                                                        T
             W                                                        W
             WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
           

   
   Dans ce tableau, il y a 3 détritus (G), avec des poubelles disposées à gauche et à droite (T), le reste étant des murs (W).

              W: wall, T: trash can, G: garbage 
            

   
   Le programme devra vérifier qu'un tableau est valide, c'est-à-dire vérifier que les bords du tableau sont bien constitués de W ou de T. Le tableau peut être de taille variable suivant les niveaux.
2. Poser les bombes
   La première phase de jeu consiste à poser des bombes sur l'écran. Pour ce faire, l'utilisateur controle Wall-J à la souris et lui indique, en cliquant sur l'écran, où il doit se positionner. Wall-J se déplace alors à l'endroit indiqué en évitant les détritus, les murs et les poubelles.
   On vous demande pour cela de programmer l'algorithme A* [wikipedia] pour permettre à Wall-J de se déplacer sans rentrer dans les obstacles.
   La touche RETURN permet de poser une bombe ; si l'on appuie plusieurs fois d'affilée sur RETURN au même emplacement, on incrémente un compteur qui va indiquer le délai (en secondes) avant que la bombe n'explose. Cela permet, lorsque toutes les bombes sont posées, de faire exploser celles-ci avec des délais différents.
3. Affichage
   Pour l'affichage, on vous demande d'utiliser la bibilothèque Zen 5.
4. Explosions
   Une fois toutes les bombes posées, une animation fait disparaître Wall-J, ce afin qu'il se cache. Puis le compteur de chaque bombe se décrémente, et dès qu'un compteur atteint zéro, la bombe associée explose et pousse les détritus. Les détritus peuvent rebondir sur les murs et disparaissent s'ils touchent une poubelle. Si, à la fin des explosions, tous les détritus ont disparu dans les poubelles, le tableau est gagné et l'utilisateur peut passer au tableau suivant.
   Pour gérer la partie physique des explosions et des mouvements des détritus, on vous demande d'utiliser la bibliothèque JBox2D 2.2.1.1 sous forme d'un jar (pour vous aider, voilà la doc et le code source).
5. Amélioration possibles
   Attention, les autres parties du jeu devront être finies avant que vous commenciez à considérer les améliorations suivantes :
   
   • ajouter des murs particuliers qui accélèrent les détritus lorsque ceux-ci rebondissent sur le mur ;
   • ajouter des bombes qui implosent au lieu d'exploser ;
   • ajouter un timer qui oblige à placer les bombes assez rapidement.
   
   Toute autre amélioration sera considérée négativement.

Références

Conditions de rendu

• un répertoire src contenant les sources du projet ;
• un répertoire docs contenant le manuel de l'utilisateur (user.pdf) et le manuel qui explique votre architecture (dev.pdf) au format PDF avec une section dédiée aux améliorations/corrections apportées depuis la soutenance bêta ;
• un répertoire classes vide dans l'archive et qui contiendra les classes une fois compilées ;
• un répertoire lib contenant les libraries dont dépend l'application ;
• un jar exécutable wallj.jar qui fonctionne avec java -jar wallj.jar et donc qui possède un fichier manifest adequat ;
• un build.xml qui permet de
  • compiler les sources (target compile) ;
  • créer le jar exécutable (target jar) ;
  • générer la javadoc dans docs/doc (target javadoc) ;
  • nettoyer le projet pour qu'il ne reste plus que les éléments demandés (target clean).

Notation

• Cas de 0 sans aucune correction (Mort subite):
  • projet non effectué en binôme (c'est-à-dire 2 personnes !) sans l'accord préalable de l'intervenant de TD ;
  • absence à la soutenance bêta ;
  • projet envoyé après la date ;
  • projet non déposé sur elearning ;
  • une archive qui n'a pas le bon nom ;
  • fichier d'archive dont l'extraction ne produit pas un répertoire qui a le bon nom ;
  • le projet utilise une ou des librairies externes autre que celles indiquées dans le sujet ;
  • présence de code copier/coller du net ;
  • l'utilisation de classes de java.io autre que InputStream/OutputStream, Reader/Writer et l'exception IOException ;
  • l'absence de javadoc, ou javadoc pas en anglais.
• Base de la notation :
  • la propreté et la lisibilité du code auront un poids très important dans la note ;
  • l'architecture que vous aurez définie (interfaces, classes ...) devra être donnée dans les documents PDF et aura également un poids très important dans la note ;
  • la duplication de code et le non-respect des principes de programmation objet ;
  • la présence de code inutile ;
  • les différents rapports et, par conséquent, l'orthographe !
  • la prise en considération des remarques faites lors de la bêta pour le rendu final