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

Projets/jeu_de_la_vie/JALONS.md

@@ -0,0 +1,80 @@
+# Jalons — Le Jeu de la Vie
+
+> Progression suggérée sur ~10 séances (septembre → février)
+
+---
+
+## Phase 1 — Analyse et modélisation (Séances 1-2)
+
+**Objectif :** Comprendre le problème et choisir les structures de données.
+
+- Lire les règles de Conway et les reformuler avec ses propres mots
+- Dessiner à la main quelques générations d'une configuration simple (ex. 3 cellules en ligne)
+- Choisir une représentation de la grille : liste 2D, dictionnaire `{(i,j): état}` ?
+- Écrire la fonction `creer_grille(n, m)` → grille vide de n lignes et m colonnes
+- Écrire la fonction `afficher_grille(grille)` → affichage terminal
+
+**Questions à se poser :**
+- Comment représenter une cellule morte / vivante en Python ?
+- Que se passe-t-il aux bords de la grille ?
+
+---
+
+## Phase 2 — Règles du jeu (Séances 3-4)
+
+**Objectif :** Implémenter le cœur de la simulation.
+
+- Écrire `compter_voisins(grille, i, j)` → nombre de voisins vivants de la cellule (i, j)
+- Écrire `etat_suivant(etat, nb_voisins)` → applique les 4 règles, renvoie le nouvel état
+- Écrire `generation_suivante(grille)` → calcule la grille à l'étape suivante
+- Tester manuellement sur un petit exemple (3×3)
+
+**Point d'attention :** la prochaine génération doit être calculée **simultanément** pour toutes les cellules — on ne modifie pas la grille en cours de calcul.
+
+---
+
+## Phase 3 — Simulation et configurations (Séances 5-6)
+
+**Objectif :** Lancer une simulation complète et observer des comportements.
+
+- Écrire `simuler(grille, nb_generations)` → boucle principale
+- Tester sur les configurations classiques :
+  - **Bloc** (stable)
+  - **Clignotant** (oscillateur période 2)
+  - **Planeur** (se déplace)
+- Observer : certaines configurations sont-elles stables ? Oscillantes ? Chaotiques ?
+
+---
+
+## Phase 4 — Affichage graphique (Séances 7-8)
+
+**Objectif :** Rendre la simulation visuelle et interactive.
+
+- Choisir une bibliothèque graphique : Pyxel, matplotlib (animation), tkinter
+- Afficher la grille avec des cellules colorées
+- Animer la simulation pas à pas avec un délai configurable
+- (Extension) Permettre à l'utilisateur de cliquer pour activer/désactiver des cellules
+
+---
+
+## Phase 5 — Finitions et documentation (Séances 9-10)
+
+**Objectif :** Préparer le rendu et le Grand Oral.
+
+- Nettoyer le code, ajouter des docstrings
+- Rédiger un README personnel décrivant le projet et les choix techniques
+- Compléter le `SUIVI.md`
+- Préparer 2-3 questions pour le Grand Oral (voir `SUIVI.md`)
+
+---
+
+## Idées d'extension avancée
+
+- **Grille torique** : `i % n` et `j % m` pour que les bords se rejoignent
+- **Statistiques** : tracer le nombre de cellules vivantes par génération (matplotlib)
+- **Chargement de patterns** : lire des fichiers `.rle` (format standard des patterns Conway)
+- **Détection de stabilité** : arrêter la simulation quand la grille ne change plus
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/jeu_de_la_vie/README.md

@@ -0,0 +1,54 @@
+# Projet — Le Jeu de la Vie
+
+> En 1970, le mathématicien John Horton Conway invente un automate cellulaire capable de générer une vie artificielle à partir de quatre règles simples. Cinquante ans plus tard, des chercheurs utilisent encore ce modèle pour simuler des phénomènes biologiques, sociaux et physiques.
+
+## Contexte
+
+Le **Jeu de la Vie** est un automate cellulaire qui se déroule sur une grille infinie (ou torique) de cellules. Chaque cellule est soit **vivante**, soit **morte**. À chaque génération, l'état de chaque cellule évolue selon quatre règles appliquées simultanément :
+
+1. Une cellule vivante avec **moins de 2 voisins vivants** meurt (sous-population).
+2. Une cellule vivante avec **2 ou 3 voisins vivants** survit.
+3. Une cellule vivante avec **plus de 3 voisins vivants** meurt (surpopulation).
+4. Une cellule morte avec **exactement 3 voisins vivants** devient vivante (reproduction).
+
+Ces règles font émerger des comportements complexes : structures stables, oscillateurs, planeurs...
+
+## Compétences mobilisées
+
+| Notion | Chapitre du cours |
+|--------|-------------------|
+| Listes 2D (grille) | Programmation |
+| Fonctions pures | Paradigmes |
+| Classes et objets | POO |
+| Récursivité / itération | Récursivité |
+| Visualisation (matplotlib / Pyxel) | — |
+
+## Cahier des charges
+
+### Fonctionnalités minimales
+
+- [ ] Représenter la grille sous forme de liste 2D (ou dictionnaire)
+- [ ] Calculer le nombre de voisins vivants d'une cellule
+- [ ] Appliquer les 4 règles pour calculer la génération suivante
+- [ ] Afficher la grille dans le terminal (caractères `█` / `.`)
+- [ ] Lancer la simulation sur N générations
+
+### Extensions possibles
+
+- [ ] Affichage graphique animé (Pyxel, matplotlib, tkinter)
+- [ ] Grille torique (les bords se rejoignent)
+- [ ] Charger des configurations célèbres (planeur, canon à planeurs, pulsar...)
+- [ ] Compter et tracer l'évolution du nombre de cellules vivantes
+- [ ] Permettre à l'utilisateur de dessiner une configuration initiale
+- [ ] Détecter automatiquement les structures stables et les oscillateurs
+
+## Ressources
+
+- `5_projet_le_jeu_de_la_vie.pdf` — consignes détaillées (dans le dossier parent)
+- [Conway's Game of Life — Wikipedia](https://fr.wikipedia.org/wiki/Jeu_de_la_vie)
+- [LifeWiki — patterns célèbres](https://conwaylife.com/wiki/)
+- [Pyxel — moteur graphique Python](https://github.com/kitao/pyxel)
+
+---
+
+Auteur : Florian Mathieu — Licence CC BY NC

Projets/jeu_de_la_vie/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 ?**