Labyrinthe_CS

jeu du Labyrinthe Via console un jeu fun et divertissant construit grâces au principes simple du langage c# image de mes premier pas dans ce langage

LE LABYRINTHE

L'Aventure Procédurale Ultime en 20 Niveaux

Niveau 1

Niveau 14

Niveau 20

---

Description

Le Labyrinthe est un jeu d'aventure en console où vous devez naviguer à travers 20 niveaux générés procéduralement, chacun avec sa propre difficulté et ses mécaniques uniques.
Trouvez les clés, évitez les pièges, utilisez des téléporteurs et des pioches pour progresser jusqu'à la victoire finale !

---

Points Forts

• Génération procédurale : Chaque partie est unique
• Progression dynamique : 20 niveaux avec difficulté croissante
• Mécaniques évolutives : Débloquez de nouveaux éléments tous les 3-4 niveaux
• Système de vie : Gérez vos points de vie stratégiquement
• Boss final : Niveau 20 avec mécanique spéciale chronométrée

---

Caractéristiques

Éléments de Gameplay

Niveau	Nouveautés
1–6	Bases : Labyrinthe, clés, sortie
7+	🔴 Cases de la mort (dégâts)
10+	❤️ Cœurs de vie (récupération)
14+	🔵 Téléporteurs (déplacement instantané)
18+	⛏️ Pioches (casser les murs)
20	⏱️ Niveau final chronométré avec danger progressif

---

Progression

Élément	Détails
Taille	Grille de 15×15 à 21×21
Obstacles	40 à 90 blocs selon le niveau
Clés	1 à 3+ clés à trouver
Difficulté	Augmente tous les 3 niveaux

---

Installation

Prérequis

• .NET Framework 4.7.2+ ou .NET 5.0+
• Windows, Linux ou macOS avec support console

Installation

# Cloner ou télécharger les 5 fichiers
git clone [votre-repo]/labyrinthe.git
cd labyrinthe

# Compiler
dotnet build

# Exécuter
dotnet run

Comment Jouer

Contrôles

Touche	Action
↑	Déplacer vers le haut
↓	Déplacer vers le bas
←	Déplacer vers la gauche
→	Déplacer vers la droite
K	Recommencer le niveau
S	Sauter à un niveau spécifique (debug)

---

Symboles

Symbole	Signification
P	Joueur
K	Clé
#	Mur
_ ou	Sortie
__	Case de la mort
__	Téléporteur
7	Pioche
V	Cœur de vie

Objectif

Collecter toutes les clés du niveau Atteindre la sortie (_ ou | ) Survivre en gérant vos vies Progresser jusqu'au niveau 20

---

Arborescence du Projet

L’organisation du projet suit une logique modulaire inspirée des bonnes pratiques C# : chaque composant a une responsabilité claire (affichage, logique, données, etc.).

Labyrinthe/
│
|
├── Demo/                      # Dossier de démonstration et tests manuels  
|                                  # Exemple de rendu et interaction visuelle
│
├── Display.cs                 # Gère tout l'affichage graphique et la fenêtre principale
├── GameData.cs                # Stocke les données persistantes du jeu (scores, états, etc.)
├── GameLogic.cs               # Contient la logique centrale du gameplay et des règles
├── LabyrinthGenerator.cs      # Algorithmes de génération procédurale des labyrinthes
│
├── Program.cs                 # Point d’entrée principal du programme
│                             # Initialise les composants et lance l'application
│
├── Labyrinthe.csproj          # Fichier de configuration du projet C#
├── Labyrinthe.sln             # Solution Visual Studio regroupant l'ensemble des projets
│
├── bin/                       # Fichiers binaires compilés (Debug / Release)
└── obj/                       # Fichiers temporaires de compilation

Conception

• Architecture procédurale modulaire : séparation claire des responsabilités

• Pas d’orienté objet : logique purement procédurale optimisée

• Gestion d’état centralisée : toutes les données dans GameData

• Algorithmes optimisés : génération rapide et validation efficace

---

Fonctionnalités Techniques

Génération Procédurale

//Génération intelligente avec exclusions Position TrouverPositionValide
(params List<Position>[] exclusions); 
// Placement automatique des éléments :
PlacerJoueur();
PlacerCles();
PlacerObstacles();
//Assure l'accessibilité de la sortie
AssurerAccessibiliteSortie();

Système de Difficulté

// Mise à jour dynamique tous les 3 niveaux
    MettreAJourDifficulte(int niveau);
// Configuration adaptative
// - Taille de grille : 15 → 21
// - Obstacles : 40-50 → 70-90
// - Cases mort : 0 → 8-18
// - Téléporteurs : 0 → 2-6
// - Pioches : 0 → 1-7

Mécanique Spéciale Niveau 20

// Danger progressif chronométré
    GererMecaniqueNiveau20();
// Toutes les 30 secondes, une ligne devient mortelle
// Pression croissante du bas vers le haut

Captures d'Écran (ASCII)

========================================================
||              | LE LABIRYNTHE |                    ||
========================================================
||              BIENVENUE MON CHER AMI               ||
||          CECI EST UN PETIT JEU AMUSANT            ||
========================================================

                  # # # # # # # # # # # # #
                  #   K     #       #     #
                  # # # #   # # #   #   # #
                  #     P       #   K     #
                  # # # # # # # # # # # # #

========================================================
|| Nombre de vie : v v v    Niveau : 5    Cles : 1/2 ||
========================================================

Statistiques

Élément	Valeur
Lignes de code	~500 (optimisé depuis 1200)
Réduction de complexité	70%
Modules	5 fichiers spécialisés
Performance	Génération instantanée (<100ms)
Rejouabilité	Infinie (génération procédurale)

---

Bugs Connus

Aucun bug majeur connu dans la version 2.0 refactorisée.

Améliorations Futures Possibles

• Sauvegarde de progression

• Système de score

• Générateur de seed pour grilles reproductibles

• Mode multijoueur

• Éditeur de niveaux

Développement

Optimisations Réalisées

Action	Résultat
Élimination de 27 variables globale	structure centralisée
Unification des déplacements	600 lignes → 50 lignes
Fonctions de validation	5 versions → 1 générique
Affichage modulaire	3 copies → 1 paramétrable
Algorithme de placement	Évite les boucles infinies

---

Principes de Conception

• DRY : Don’t Repeat Yourself

• Séparation des responsabilités : chaque module a un rôle unique

• Validation stricte : toutes les entrées sont vérifiées

• Gestion d’erreurs : aucun plantage possible

Licence

Ce projet est fourni à des fins éducatives et de démonstration.

Crédits

Entièrement réaliser par Moi : Kryss Rayane Sampi Nana

Méthodologie de Conception

Étape Principale	Description	Objectifs Clés	Livrables / Résultats
Conception Mentale	Phase de réflexion initiale où l’idée brute est structurée. On établit le cahier des charges, on visualise le produit final, et on crée une carte mentale pour relier les concepts.	- Définir la vision globale du projet - Identifier les besoins réels et les contraintes - Clarifier les fonctions essentielles	- Cahier des charges clair et hiérarchisé - Schémas et mind maps - Vision conceptuelle aboutie
Maquettage Visuel	Création de maquettes et prototypes statiques permettant de visualiser la disposition générale, la navigation, les composants clés et le ton visuel du produit.	- Définir la direction artistique et UX - Obtenir une vue d’ensemble claire du futur produit - Préparer la base du design interactif	- Maquettes (Figma, Adobe XD, ou papier) - Palette de couleurs et typographies - Grilles et disposition des sections
Réalisation Graphique & Animation Visuelle	Implémentation des interfaces graphiques (UI) et des animations sans logique interne (no-mechanism). On travaille sur le rendu visuel, les transitions et l’ergonomie.	- Donner vie à la maquette - Tester l’esthétique et la fluidité visuelle - S’assurer de la cohérence stylistique	- Interfaces fonctionnelles (front-end, XAML, CSS, etc.) - Animations, transitions et effets - Design stable et interactif
Implémentation des Mécanismes & Cœur du Programme	Développement de la logique interne : base de données, gestion d’état, algorithmes, et intégration entre l’interface et le backend.	- Structurer le cœur logique du système - Garantir la performance et la stabilité - Centraliser les données et interactions	- Code source stable et modulaire - Base de données fonctionnelle - Mécanismes et API opérationnels
Tests & Polissage Final	Étape de test approfondi et de correction. On explore la majorité des cas d'utilisation possibles, puis on ouvre le projet à une communauté restreinte pour recueillir des retours.	- Déceler les bugs et incohérences - Ajuster le rendu visuel et l’expérience utilisateur - Stabiliser le produit avant diffusion	- Rapport de test et correctifs - Version stable (v1.0+) - Interface polie et réactive
Publication & Partage	Mise en ligne du produit final et partage avec le public ou un cercle professionnel. Cette phase marque la transition vers l’usage réel.	- Diffuser le travail accompli - Obtenir des retours d’expérience - Débuter l’utilisation régulière et la maintenance	- Version publique du projet - Documentation claire - Utilisation continue et mises à jour futures

" De la vision à la réalité, chaque étape est une brique de maîtrise. "

Support

Pour toute question ou suggestion :

• Ouvrir une issue sur GitHub
• Consulter la documentation dans les commentaires du code
• Chaque fonction est documentée avec XML comments

"Le Labyrinthe - Où chaque partie est une nouvelle aventure"