Vue d’ensemble de l’architecture

Cette page présente l’architecture globale du projet SnackAnarchy et sert de point d’entrée à la référence développeur.

Dossiers principaux

À la racine du projet de jeu :

• config.py : configuration globale du jeu (paramètres, constantes, options de partie, chemins d’assets…).
• main.py : point d’entrée : initialisation, boucle de jeu principale, création de la fenêtre.
• game/ : logique de gameplay (clients, plats, inventaire, sabotages, mini‑jeux, événements, état du jeu…).
• rendering/ : rendu visuel, caméra, menus, split-screen, inventaires, écrans de configuration.
• input/ : gestion des contrôles joueurs (controls.py) et configuration des touches (keybindings.json).
• assets/ : ressources graphiques, cartes .tmx, sons, vidéos.

Les sous‑pages de la section dev/ détaillent ensuite :

• les modules de gameplay (dev/game-modules) ;
• le rendu & les entrées (dev/rendering-input) ;
• le pipeline d’assets (dev/assets-pipeline) ;
• les règles de contribution (dev/contributing).

Flux principal du jeu

Le fichier main.py contient généralement une classe centrale Game qui orchestre la partie :

1. Initialisation :
   • initialisation de Pygame et du mixer audio ;
   • chargement des assets (sprites, sons, vidéos) via game/assets_loader.py ;
   • création de l’objet GameState (dans game/state.py) qui contient l’état courant du monde.
2. Boucle principale :
   • lecture des événements Pygame (clavier/manette, fermeture de fenêtre, etc.) ;
   • passage des entrées au système input/controls.py ;
   • mise à jour de GameState (clients, joueurs, commandes, sabotages, temps restant…) ;
   • appel des différents renderers dans rendering/ (menus, split‑screen, inventaire, écran de fin).
3. Cycle de vie :
   • menu principal → configuration des joueurs → partie → pause/fin de partie → retour menu.

Schéma d’architecture (simplifié)

Le diagramme suivant résume les échanges entre les principaux blocs du jeu :

flowchart LR
  playerInputs["Entrees_joueurs_(clavier)"] --> inputHandler[InputHandler]
  inputHandler --> gameState[GameState]
  gameState --> clients[Clients_Commandes]
  gameState --> inventory[Inventaire_Sabotages]
  gameState --> events[Evenements]
  gameState --> rendering[Renderers]
  rendering --> screen["Ecran_split_screen"]

• InputHandler est implémenté dans input/controls.py et traduit les touches en actions haut niveau (se déplacer, interagir, attaquer, ouvrir l’inventaire, lancer un sabotage…).
• GameState (dans game/state.py) centralise :
  • les joueurs (game/player.py) ;
  • les clients et leurs commandes (game/client.py, game/dishes.py) ;
  • l’inventaire et le stock (game/inventory.py) ;
  • les sabotages (game/sabotage.py) et événements globaux (game/events.py) ;
  • le score et la réputation.
• Les modules rendering/* lisent l’état de GameState pour dessiner :
  • la carte et les entités (clients, joueurs, équipements…) ;
  • les interfaces (menus, inventaire, mini‑jeux, écrans de transition).

Aller plus loin

• Pour le détail des sous‑modules de gameplay : voir dev/game-modules.
• Pour la gestion du rendu, du split‑screen et des menus : voir dev/rendering-input.
• Pour la structure des assets et leur chargement : voir dev/assets-pipeline.
• Pour contribuer ou ajouter du contenu (plats, sabotages, mini‑jeux) : voir dev/contributing.