Modules de gameplay (game/)

Le dossier game/ contient la majeure partie de la logique métier de SnackAnarchy.
Cette page résume le rôle de chaque fichier important et indique où étendre le jeu.

animation.py

Gère les animations :

• sprites animés (clients, joueurs, éléments de décor) ;
• gestion des états d’animation (marche, idle, attaque, etc.).

Tu touches à ce module si tu ajoutes :

• de nouveaux sprites animés,
• de nouveaux états visuels pour des entités existantes.

assets_loader.py

Responsable du chargement des ressources :

• images / sprites (PNG, etc.) ;
• cartes Tiled (.tmx) ;
• sons et musiques ;
• vidéos éventuelles (comme le fond du menu).

Objectifs :

• centraliser le chargement pour éviter les duplicata en mémoire ;
• uniformiser les chemins et formats d’assets ;
• proposer une API simple pour les autres modules (get_sprite("player1"), etc.).

audio.py

Gère l’audio du jeu :

• musiques d’ambiance (music_ambient.wav) ;
• effets sonores (prise de commande, réussite/échec, sabotages, fin de partie…) ;
• fonctions utilitaires pour jouer/arrêter/changer de piste.

Pour ajouter un nouveau son :

• place le fichier dans assets/ (sous-dossier audio) ;
• ajoute son chargement dans assets_loader.py (si nécessaire) ;
• déclenche-le depuis audio.py ou directement depuis les modules de gameplay.

client.py

Définit la logique des clients :

• représentation des états (arrivée, attente, servi, en colère, parti, mort) ;
• association d’un client à une commande (plat) ;
• mise à jour de la patience et de la satisfaction ;
• interactions avec les joueurs (service, meurtre, sabotage).

En pratique, GameState manipule des instances de client pour :

• les placer dans la bonne file d’attente ;
• déclencher la fin de vie (service réussi, fuite, mort).

dishes.py

Décrit les plats disponibles :

• nom du plat ;
• ingrédients requis ;
• éventuelles métadonnées (temps de préparation, type de plat…).

C’est le bon endroit pour :

• ajouter un nouveau plat : définir sa recette et l’intégrer à RECIPES dans inventory.py ;
• ajuster l’équilibrage (ingrédients plus ou moins coûteux/rares).

equipment.py

Gère les équipements des restaurants :

• friteuse, broche, caisse, toilettes, etc. ;
• états possibles :
  • OK (fonctionne),
  • en cours d’utilisation,
  • cassé/saboté ;
• temps de réparation éventuels.

Les sabotages et événements modifient souvent l’état des équipements définis ici.

events.py

Contient les événements de jeu globaux :

• système EventManager qui :
  • vérifie régulièrement s’il faut déclencher un événement ;
  • choisit un type d’événement (inspection sanitaire, etc.) ;
  • applique son effet à un ou plusieurs joueurs.

C’est un bon point d’entrée pour :

• ajouter un nouvel événement aléatoire ;
• ajuster la fréquence des événements existants.

inventory.py

Gère l’inventaire et le stock :

• classe FoodStock pour le stock global de chaque restaurant ;
• dictionnaire RECIPES qui relie les plats aux ingrédients ;
• PlayerInventory pour l’inventaire portatif (armes, etc.).

Les mécanismes décrits dans la page Inventaire & armes de la doc systèmes reposent sur ce module.

map.py

Gère la carte et le niveau :

• chargement des fichiers .tmx (Tiled) ;
• extraction des calques de collisions ;
• positionnement des équipements, zones de service, spawn de clients, etc.

Si tu ajoutes une nouvelle carte ou un nouveau layout :

• crée un .tmx dans assets/ ;
• adapte map.py pour le charger et l’utiliser.

minigames.py

Contient la logique des mini‑jeux :

• définition des différents mini‑jeux ;
• boucle de mise à jour spécifique (inputs, timing, jauges…) ;
• renvoi du résultat (succès/échec) vers GameState.

Pour ajouter un mini‑jeu :

• ajouter une nouvelle classe/fonction dans minigames.py ;
• brancher son déclenchement depuis state.py ou d’autres modules.

player.py

Définit les joueurs :

• position, vitesse, direction, zone actuelle (rue, tacos, kebab) ;
• état (libre, en interaction, dans un mini‑jeu…) ;
• référence vers l’inventaire joueur ;
• méthodes d’interaction avec le monde (ramasser, déposer, utiliser un équipement, attaquer).

sabotage.py

Regroupe les systèmes de sabotage :

• définition des types de sabotages disponibles ;
• conditions de déclenchement (coût, proximité, cooldown) ;
• effets appliqués sur l’état du jeu (casse équipements, stock, réputation…).

C’est le point d’entrée pour :

• créer un nouveau sabotage ;
• modifier les paramètres (coût, durée, impact).

state.py

Module central de l’état du jeu (GameState) :

• score, temps restant, phase (menu, jeu, fin de partie) ;
• listes de clients, joueurs, armes, sabotages en cours ;
• logique de spawn de clients, mise à jour des timers, calcul de réputation ;
• transition entre les écrans (début/fin de partie, pause).

Si tu cherches “où se passe la magie”, c’est souvent dans GameState.