Projets : structure par projet (jeu_de_la_vie, labyrinthe, mastermind, wator)

Projets/labyrinthe/JALONS.md

@@ -0,0 +1,88 @@
+# Jalons — Labyrinthe
+
+> Progression suggérée sur ~10 séances (septembre → février)
+
+---
+
+## Phase 1 — Modélisation (Séances 1-2)
+
+**Objectif :** Représenter un labyrinthe en Python.
+
+- Étudier la classe `Maze` dans `../src/maze.py` : comment est codé le labyrinthe ? Quelles méthodes sont disponibles ?
+- Choisir une représentation : dictionnaire `{cellule: [voisins accessibles]}` ou grille 2D avec murs
+- Écrire `creer_grille(n, m)` → grille n×m avec tous les murs fermés
+- Écrire `afficher(grille)` → affichage terminal avec `+`, `-`, `|`, ` `
+
+**Exemple de représentation :**
+```
++--+--+--+
+|     |  |
++  +--+  +
+|  |     |
++--+--+--+
+```
+
+---
+
+## Phase 2 — Génération (Séances 3-4)
+
+**Objectif :** Générer un labyrinthe parfait aléatoirement.
+
+**Algorithme DFS récursif (backtracking) :**
+1. Partir d'une cellule aléatoire, la marquer comme visitée
+2. Choisir aléatoirement un voisin non visité
+3. Supprimer le mur entre les deux cellules
+4. Appeler récursivement depuis le voisin
+5. Si aucun voisin non visité : revenir en arrière (backtrack)
+
+- Implémenter `generer_dfs(grille, cellule)` de manière récursive
+- Tester sur un labyrinthe 5×5, puis 20×20
+- Observer : le labyrinthe est-il toujours parfait (sans cycle) ?
+
+---
+
+## Phase 3 — Résolution (Séances 5-6)
+
+**Objectif :** Trouver le chemin de l'entrée à la sortie.
+
+- Implémenter `resoudre_bfs(grille, entree, sortie)` → plus court chemin (largeur d'abord)
+- Implémenter `resoudre_dfs(grille, entree, sortie)` → premier chemin trouvé (profondeur d'abord)
+- Comparer les deux : même longueur de chemin ? Même rapidité ?
+- Afficher le chemin dans le labyrinthe (ex. cellules marquées `*`)
+
+**Point clé :** dans un labyrinthe parfait, BFS et DFS trouvent tous les deux le chemin (unique), mais BFS garantit qu'il est le plus court.
+
+---
+
+## Phase 4 — Affichage graphique (Séances 7-8)
+
+**Objectif :** Visualiser la génération et la résolution.
+
+- Choisir une bibliothèque graphique (Pyxel, tkinter, pygame)
+- Afficher le labyrinthe avec des rectangles
+- Animer la génération cellule par cellule
+- Afficher le chemin solution en couleur
+
+---
+
+## Phase 5 — Finitions et documentation (Séances 9-10)
+
+**Objectif :** Préparer le rendu et le Grand Oral.
+
+- Nettoyer le code, ajouter des docstrings
+- Mesurer les performances : temps de génération selon la taille (10×10, 50×50, 100×100)
+- Compléter le `SUIVI.md`
+- Préparer 2-3 questions pour le Grand Oral
+
+---
+
+## Idées d'extension avancée
+
+- **A\*** : heuristique distance de Manhattan pour guider la recherche vers la sortie
+- **Kruskal** : algorithme de génération alternatif (union-find)
+- **Résolution par algo génétique** : utiliser le framework du projet `mastermind/`
+- **Labyrinthe 3D** : extension vers une grille à 3 dimensions
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/labyrinthe/README.md

@@ -0,0 +1,51 @@
+# Projet — Labyrinthe
+
+> Générer un labyrinthe parfait (sans boucles, avec un unique chemin entre deux cases) et le résoudre automatiquement — un problème classique qui mobilise graphes, récursivité et algorithmique de recherche.
+
+## Contexte
+
+Un **labyrinthe parfait** est un graphe dans lequel il existe exactement un chemin entre n'importe quelle paire de cellules. Le générer revient à construire un arbre couvrant d'une grille ; le résoudre revient à parcourir ce graphe de l'entrée à la sortie.
+
+Ce projet relie directement le chapitre **Graphes** et le chapitre **Récursivité** du programme de Terminale NSI.
+
+Une base de code est disponible dans `../src/maze.py` : la classe `Maze` lit un labyrinthe depuis un fichier texte et permet de tester un chemin.
+
+## Compétences mobilisées
+
+| Notion | Chapitre du cours |
+|--------|-------------------|
+| Graphes, arbres couvrants | Graphes |
+| Parcours DFS / BFS | Graphes, Récursivité |
+| Récursivité et pile d'appels | Récursivité |
+| Classes et encapsulation | POO |
+| Représentation par dictionnaire | Programmation |
+
+## Cahier des charges
+
+### Fonctionnalités minimales
+
+- [ ] Représenter un labyrinthe sous forme de graphe (dictionnaire de voisins)
+- [ ] Générer un labyrinthe parfait aléatoire (algorithme DFS récursif ou union-find/Kruskal)
+- [ ] Afficher le labyrinthe dans le terminal (avec `+`, `-`, `|`, ` `)
+- [ ] Résoudre le labyrinthe (trouver un chemin de l'entrée à la sortie) avec BFS ou DFS
+- [ ] Afficher le chemin solution
+
+### Extensions possibles
+
+- [ ] Affichage graphique (Pyxel, tkinter)
+- [ ] Visualisation animée de la génération et de la résolution
+- [ ] Comparer BFS (plus court chemin) et DFS (premier chemin trouvé)
+- [ ] Implémenter l'algorithme A* (heuristique distance de Manhattan)
+- [ ] Résolution par algorithme génétique (en lien avec le projet `mastermind/`)
+- [ ] Mesurer les performances selon la taille du labyrinthe
+
+## Ressources
+
+- `../src/maze.py` — classe `Maze` de base (lecture depuis fichier texte)
+- `../src/maze.zip` — archive complète avec exemples de labyrinthes
+- [Maze generation algorithms — Wikipedia](https://en.wikipedia.org/wiki/Maze_generation_algorithm)
+- [Algorithme A* — Wikipedia](https://fr.wikipedia.org/wiki/Algorithme_A*)
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/labyrinthe/SUIVI.md

@@ -0,0 +1,72 @@
+# Suivi de projet — [Nom du projet]
+
+**Élève(s) :**
+**Classe :**
+**Projet :**
+**Date de début :**
+
+---
+
+## Journal de bord
+
+*Compléter après chaque séance.*
+
+### Séance 1 — [Date]
+
+**Objectif de la séance :**
+
+**Ce que j'ai fait :**
+
+**Difficultés rencontrées :**
+
+**Décisions prises et pourquoi :**
+
+**Ce qu'il reste à faire :**
+
+---
+
+### Séance 2 — [Date]
+
+**Objectif de la séance :**
+
+**Ce que j'ai fait :**
+
+**Difficultés rencontrées :**
+
+**Décisions prises et pourquoi :**
+
+**Ce qu'il reste à faire :**
+
+---
+
+*(Dupliquer le bloc ci-dessus pour chaque séance)*
+
+---
+
+## Bilan du projet
+
+### Ce qui fonctionne
+
+### Ce qui ne fonctionne pas encore (et pourquoi)
+
+### Choix techniques importants
+
+*Quelles décisions as-tu prises ? Pourquoi ce choix plutôt qu'un autre ?*
+
+### Ce que j'ai appris
+
+---
+
+## Préparation au Grand Oral
+
+*Le Grand Oral dure 20 minutes. Tu dois pouvoir présenter ton projet et répondre à des questions. Prépare-toi en répondant à ces questions :*
+
+**1. En quoi consiste ton projet ? Explique-le en 2 minutes à quelqu'un qui ne connaît pas l'informatique.**
+
+**2. Quelles notions du cours as-tu utilisées ? Donne un exemple concret dans ton code.**
+
+**3. Quelle a été la difficulté principale ? Comment l'as-tu résolue ?**
+
+**4. Qu'aurais-tu fait différemment si tu recommençais ?**
+
+**5. Quelle extension aimerais-tu implémenter si tu avais plus de temps ?**