Fiche de révision : Gestion des commandes dans un jeu d'aventure

Fiche de Révision : Module Actions d’un Jeu d’Aventure Textuel

1. 📌 L'essentiel

• La classe Actions gère les commandes principales : go, quit, help.
• La commande go déplace le joueur selon une direction (N, E, S, O).
• La commande quit termine le jeu avec un message de fin.
• La commande help affiche la liste des commandes disponibles.
• La classe Command représente une commande avec mot-clé, description, action, et nb_params.
• La classe Player possède une méthode move() qui change la pièce courante.
• La classe Room décrit un lieu avec ses sorties et sa description longue.
• La classe Game initialise l’environnement, configure commandes et pièces, et gère la boucle principale.
• Vérification des paramètres : MSG0 si pas de paramètre, MSG1 si un seul paramètre.
• La gestion des sorties utilise un dictionnaire dans Room pour le déplacement.
• La boucle de jeu s’arrête lorsque game.finished devient True.

2. 🧩 Structures & Composants clés

• Classe Actions — contient méthodes pour commandes (go, quit, help).
• Classe Command — stocke mot-clé, description, action, nb_params.
• Classe Player — nom, pièce courante, méthode move(direction).
• Classe Room — nom, description, sorties, méthodes get_exit(), get_long_description().
• Classe Game — initialise le jeu, configure commandes, boucle principale.
• Messages d’erreur — MSG0 (pas de param), MSG1 (un seul param).
• Vérification paramètres — dans chaque commande selon nb_params.
• Gestion des sorties — dans Room via dictionnaire exits.
• Interprétation des commandes — dans process_command().

3. 🔬 Fonctions, Mécanismes & Relations

• go(direction) : vérifie nb_params, si valide, déplace le joueur via player.move(direction).
• quit() : vérifie nb_params, met game.finished = True, affiche message de fin.
• help() : affiche toutes les commandes disponibles avec leur description.
• Command : instancie une commande avec mot-clé, description, action, nb_params.
• Player.move(direction) : utilise current_room.get_exit(direction) pour changer de pièce.
• Room.get_exit(direction) : retourne la pièce dans la direction donnée ou None.
• Room.get_long_description() : combine description et sorties pour affichage.
• Game.play() : boucle principale, lit commandes, exécute actions, vérifie fin.

4. Tableau comparatif

5. Diagramme hiérarchique ASCII

Game
 ├─ setup()
 ├─ play()
 │    ├─ lecture commande
 │    └─ exécution action
 └─ process_command()
      ├─ go
      ├─ quit
      └─ help

Actions
 ├─ go(direction)
 ├─ quit()
 └─ help()

Command
 ├─ command_word
 ├─ help_string
 ├─ action
 └─ nb_params

Player
 ├─ move(direction)
 └─ current_room

Room
 ├─ get_exit(direction)
 └─ get_long_description()

6. Pièges & Confusions fréquentes

• Confondre MSG0 et MSG1 lors de la vérification des paramètres.
• Oublier de vérifier si la sortie dans la direction existe (None).
• Ne pas mettre à jour current_room après déplacement.
• Confondre get_exit() et get_long_description().
• Omettre la boucle principale dans play().
• Ne pas gérer le cas où la direction n’est pas valide.
• Confondre commandes go et autres commandes.
• Oublier de définir game.finished à True pour terminer.

7. ✅ Checklist Examen Final

• Connaître la structure de la classe Actions et ses méthodes.
• Savoir comment la commande go vérifie et déplace le joueur.
• Comprendre la gestion des paramètres et des messages d’erreur.
• Savoir comment la classe Command facilite la gestion des commandes.
• Expliquer le rôle de Player.move() et comment il utilise get_exit().
• Décrire le fonctionnement de Room.get_long_description().
• Connaître la boucle principale dans Game.play().
• Savoir comment afficher la liste des commandes avec help().
• Identifier les erreurs fréquentes lors de la gestion des sorties.
• Être capable de représenter l’organisation spatiale du jeu en ASCII.
• Maîtriser la vérification des paramètres pour chaque commande.
• Comprendre le flux global de traitement d’une commande.
• Savoir comment terminer proprement le jeu avec quit().
• Être capable d’écrire ou d’interpréter une hiérarchie de classes pour ce module.
• Connaître l’importance de game.finished pour la boucle de jeu.
• Savoir utiliser le dictionnaire exits dans Room pour la navigation.