Sokoban

Ce document fournit une vue d’ensemble complète du projet Sokoban, incluant ses objectifs, son installation, son utilisation et son architecture technique pour faciliter la maintenance et les développements futurs.

1. Objectifs du Projet

Le projet a pour but de fournir une implémentation complète et extensible du jeu classique Sokoban en langage Python.

Les principaux objectifs sont :

• Jeu Classique : Respecter les règles traditionnelles du Sokoban (pousser des caisses sur des cibles).
• Architecture Modulaire : Utilisation du patron de conception MVC (Modèle-Vue-Contrôleur) pour séparer la logique du jeu de son affichage.
• Génération Procédurale : Capacité à générer une infinité de niveaux avec différents degrés de difficulté.
• Vue Hybride : Offrir une visualisation classique en 2D ainsi qu’une vue expérimentale en 3D (isométrique/perspective).

2. Dépendances

Le projet repose principalement sur le langage Python et la bibliothèque Pygame.

Pré-requis

• Python 3.x
• Pygame (version 2.6.0 ou supérieure recommandée)

Installation des dépendances

Vous pouvez installer les dépendances nécessaires via la commande suivante à la racine du projet :

pip install -r requirements.txt

Si le fichier requirements.txt n’est pas présent, installez simplement pygame : pip install pygame.

3. Mode Opératoire

Lancement du Jeu

Le projet dispose de deux points d’entrée principaux :

1. Mode Classique (2D) :
   Exécutez le fichier main.py pour lancer le jeu avec l’interface et la vue 2D par défaut. python main.py
2. Mode 3D (Expérimental) :
   Exécutez le fichier main3D.py pour lancer le jeu avec une vue 3D par défaut. Ce mode permet également de basculer entre la vue 2D et 3D en temps réel.
   bash python main3D.py

Commandes en Jeu

Touche	Action
Flèches Directionnelles	Déplacer le joueur (Haut, Bas, Gauche, Droite)
U	Annuler le dernier mouvement (Undo)
R	Recommencer le niveau actuel
V	Basculer entre la vue 2D et la vue 3D (uniquement via main3D.py)
ESC	Retourner au menu principal ou quitter
Entrée	Commencer le jeu (depuis le menu)

Génération de Niveaux

Le script regenerate_levels.py permet de générer de nouveaux niveaux de manière procédurale.

Usage :

python regenerate_levels.py [Facile|Moyen|Difficile]

Par défaut, le script génère 40 niveaux de difficulté « Facile ». Les niveaux générés sont sauvegardés dans le dossier levels/.

4. Architecture et Maintenance

La structure du projet est organisée comme suit pour faciliter la maintenance :

Dossiers et Fichiers Principaux

• Racine :
  • main.py : Point d’entrée pour le jeu standard (utilise GameController).
  • main3D.py : Point d’entrée pour la variante 3D (étend le contrôleur pour gérer la vue 3D).
  • regenerate_levels.py : Script utilitaire pour la génération de niveaux.
  • requirements.txt : Liste des dépendances.
• src/ (Code Source) :
  • model.py : Contient la logique pure du jeu (règles, état du plateau, déplacements). Indépendant de l’affichage.
  • view.py : Gère l’affichage en 2D avec Pygame (sprites, grille, menu).
  • view3d.py : Gère l’affichage en pseudo-3D/isométrique.
  • controller.py : Orchestre les interactions entre le modèle et la vue (boucle de jeu, gestion des événements).
  • generator.py : Algorithme de génération procédurale de niveaux.
• levels/ : Contient les fichiers .txt des niveaux générés.
• assets/ : Ressource graphiques (images) et sonores.

Points d’Attention pour la Maintenance

• Logique du Jeu : Toute modification des règles (conditions de victoire, collisions) doit se faire uniquement dans src/model.py.
• Ajout de Fonctionnalités Graphiques :
  • Pour la 2D, modifier src/view.py.
  • Pour la 3D, modifier src/view3d.py.
• Génération de Niveaux : L’algorithme de génération (src/generator.py) peut être ajusté pour créer des structures plus complexes ou modifier l’équilibre difficulté/taille.

5. Améliorations Possibles

Voici quelques pistes pour enrichir le projet :

1. Interface Utilisateur (UI) :
   • Améliorer l’esthétique du menu principal.
   • Ajouter un menu de sélection de niveaux.
   • Intégrer des boutons cliquables fonctionnels dans la vue 3D (actuellement limités à la vue 2D).
2. Graphismes et Audio :
   • Remplacer les rendus procéduraux de la vue 3D par de vraies textures ou modèles si nécessaire.
   • Ajouter des effets sonores (déplacement, victoire) et une musique de fond.
   • Ajouter des animations de transition pour les mouvements (interpolation).
3. Fonctionnalités de Gameplay :
   • Ajouter un système de scores (nombre de pas, temps).
   • Sauvegarder la progression du joueur (déjà partiellement implémenté avec save.txt, à fiabiliser).
   • Ajouter un éditeur de niveaux manuel.
4. Technique :
   • Optimiser l’affichage 3D pour les grands niveaux.
   • Refactoriser main3D.py pour mieux intégrer le basculement de vue directement dans le contrôleur principal si la fonctionnalité devient permanente.

SOURCE