feat(godot): moteur terrestre jouable, menus, IA et CI headless

Changelog 2026-05-24 — détail complet dans godot/CHANGELOG.md
(hors dépôt Unity legacy ; ne couvre pas la migration en soi).

Réalisé :
- Moteur core : camps, pièces, état de partie, ordres par camp (max 5),
  déplacements terrestres, résolution combat simplifiée, capture drapeau QG
- Catalogue 56 secteurs + graphe terrestre (45 cases, Dep_terre.js → JSON)
- Flux menu → config partie → bataille (GameSession autoload)
- UI bataille debug : déplacements joueur Vert, fin de manche, journal
- IA paramétrée (Facile/Normal/Difficile) : scoring, attaque, expansion
- Tests headless smoke + workflow GitHub Actions Godot 4.6.3

À faire :
- Mer / air (Dep_mer.js, Dep_air.js)
- Jetons Power, réserve, échanges, bombes H, règles complètes
- Plateau visuel + assets, UI bataille finale, tutoriel, audio
- Multijoueur (WebSocket / ENet), export mobile

Author: tlloancy

.github/workflows/godot-headless.yml

@@ -0,0 +1,31 @@
+name: Godot headless
+
+on:
+  push:
+    paths:
+      - "godot/**"
+      - ".github/workflows/godot-headless.yml"
+  pull_request:
+    paths:
+      - "godot/**"
+
+jobs:
+  smoke:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Godot 4.6
+        run: |
+          wget -q https://github.com/godotengine/godot/releases/download/4.6.3-stable/Godot_v4.6.3-stable_linux.x86_64.zip
+          unzip -q Godot_v4.6.3-stable_linux.x86_64.zip
+          chmod +x Godot_v4.6.3-stable_linux.x86_64
+          echo "GODOT_BIN=$PWD/Godot_v4.6.3-stable_linux.x86_64" >> "$GITHUB_ENV"
+
+      - name: Smoke tests
+        working-directory: godot
+        run: $GODOT_BIN --headless --path . "res://scenes/headless_test.tscn"
+
+      - name: Compile main scene
+        working-directory: godot
+        run: $GODOT_BIN --headless --path . "res://scenes/menu/main_menu.tscn" --quit-after 2

README.md

@@ -2,3 +2,10 @@
 Projet Unity fait à trois sous mon impulsion durant le premier stage de l'école 42. Supposé imiter le jeu de plateau "Power"
 
 Lien de téléchargement du jeu sur l'applestore: https://play.google.com/store/apps/details?id=com.QD.Forc2 . Personne ne savait coder vraiment (1 an à peine)
+
+## Port Godot 4
+
+Le portage actif se fait sur la branche **`godot4-port`**, dans le dossier [`godot/`](godot/).
+
+- Ouvrir `godot/project.godot` avec Godot 4.6 (ou 4.x)
+- Voir [`godot/README.md`](godot/README.md) pour l’architecture

godot/.gitignore

@@ -0,0 +1,25 @@
+# Godot 4
+.godot/
+tools/godot.env
+*.translation
+export.cfg
+export_presets.cfg
+
+# Imported artifacts
+*.import
+
+# OS / IDE
+.DS_Store
+Thumbs.db
+*.swp
+.vscode/
+
+# Builds
+build/
+exports/
+*.apk
+*.aab
+*.ipa
+*.exe
+*.pck
+*.zip

godot/CHANGELOG.md

@@ -0,0 +1,109 @@
+# Changelog — Forces Godot 4
+
+Journal des évolutions du dossier `godot/` (hors dépôt Unity legacy).
+
+---
+
+## 2026-05-24 — Moteur jouable, menus, IA, CI headless
+
+### Réalisé
+
+#### Moteur (`scripts/core/`)
+
+- **`game_constants.gd`** — camps (Vert/Bleu/Rouge/Jaune), types de pièces, stats force/portée/coût Power, phases de partie, couleurs UI.
+- **`board_catalog.gd`** — catalogue des 56 secteurs (depuis `Biblidecor.js`) : QG, neutralité, appartenance camp, `hq_for_camp()`.
+- **`board_graph.gd`** — graphe terrestre chargé depuis `data/land_adjacency.json` : voisins move-1 / move-3, BFS distance, `land_destinations()`.
+- **`game_state.gd`** — état de partie : pièces, camps vivants, jetons Power (structure), ordres **par camp** (`orders_by_camp`, max 5/manche), pièces déjà déplacées (`pieces_moved_this_round`), spawn initial (4 types × 2 au QG), `try_move_piece()` / `try_move_human_piece()`, fin de manche + capture drapeau QG, signaux phase/manche/déplacement.
+- **`game_order.gd`** — ordre typé (MOVE) avec description texte.
+- **`piece_instance.gd`** — instance pièce (id, camp, type, secteur, réserve).
+- **`battle_resolver.gd`** — résolution simplifiée des conflits : somme des forces par camp sur un secteur, capture des pièces perdantes (égalité = pas de capture).
+
+#### Données & outils
+
+- **`data/land_adjacency.json`** — 45 secteurs terrestres extraits de `Dep_terre.js` (move_1 et move_3).
+- **`tools/parse_dep_terre.py`** — régénération du JSON depuis le legacy Unity.
+- **`tools/run_headless.ps1`** / **`run_headless.sh`** — modes `smoke`, `compile`, `import` ; lecture optionnelle de `tools/godot.env` pour `GODOT_BIN`.
+- **`tools/godot.env.example`** — modèle de config locale (gitignored : `godot.env`).
+
+#### Session & menus (`scripts/app/`, `scripts/menu/`, `scenes/menu/`)
+
+- **`GameSession`** (autoload) — config persistée menu → bataille : camp humain (Vert par défaut), slots Bleu/Rouge/Jaune (IA ou joueur humain futur), difficulté IA (Facile / Normal / Difficile), volumes musique/SFX (structure).
+- **`main_menu.tscn`** — Jouer, Partie rapide, Tutoriel, Options, Quitter.
+- **`game_setup.tscn`** — configuration des camps adverses + difficulté IA ; résumé avant lancement.
+- **`options_menu.tscn`** — sliders volume (UI seulement, pas encore branchés audio).
+- **`tutorial_menu.tscn`** — placeholder tutoriel.
+- **`menu_theme.gd`** — styles communs menus.
+
+#### Bataille (`scripts/battle/`, `scenes/battle/`)
+
+- **`battle.tscn`** + **`battle.gd`** — UI debug fonctionnelle : liste secteurs, pièces du joueur, destinations terrestres, journal RichText, bouton **Fin de manche**, retour menu.
+- Déplacements terrestres du camp humain validés en jeu (F5).
+- Compteur « Vos ordres X/5 ».
+- À la fin de manche : exécution **`AiPlanner.run_all_ai()`** puis résolution combats ; détection victoire basique (≤ 1 camp vivant après manche 1).
+
+#### IA (`scripts/ai/`)
+
+- **`ai_planner.gd`** — IA unique paramétrée par difficulté (agressivité 0.35 / 0.62 / 0.88) :
+  - cible QG ennemi le plus proche (BFS terrestre) ;
+  - scoring destinations : attaque favorable, expansion territoire, progression vers QG, défense QG ;
+  - priorité pièces par force de combat ;
+  - max 5 ordres / manche, une pièce déplacée une fois par manche.
+- Preload explicite dans `battle.gd` et `headless_test.gd` (class_name non indexée en CLI sans cache éditeur).
+
+#### Tests & CI
+
+- **`scenes/headless_test.tscn`** + **`headless_test.gd`** — smoke : BoardGraph, GameSession, GameState, **AiPlanner** (Bleu joue ≥ 1 ordre), chargement scènes menu/bataille.
+- **`.github/workflows/godot-headless.yml`** — Godot 4.6.3 Linux, which `godot/**` : smoke + compile menu.
+- Dernière exécution locale validée : `smoke` exit 0, `compile` exit 0.
+
+#### Projet
+
+- **`project.godot`** — Godot 4.6, scène principale = menu, autoloads GameConstants / BoardCatalog / BoardGraph / GameSession, renderer mobile.
+- **`README.md`** (racine Forces) — lien vers branche `godot4-port` et dossier `godot/`.
+- Suppression de l’ancienne scène orpheline `scenes/main.tscn` (remplacée par le flux menu).
+
+### Non réalisé (prochaines étapes)
+
+#### Graphe & déplacements
+
+- [ ] Parser **`Dep_mer.js`** → `data/sea_adjacency.json` + API `BoardGraph.sea_*`.
+- [ ] Parser **`Dep_air.js`** → `data/air_adjacency.json` + API `BoardGraph.air_*`.
+- [ ] Types navals / aériens (Croiseur mer, Bombardier, Chasseur lourd, Destroyer) — règles move depuis secteurs mer / air.
+- [ ] Cases **Space_*** et règles spéciales non terrestres.
+
+#### Moteur & règles Power
+
+- [ ] Jetons **Power** : gain, dépense, achat de pièces (`orders.js`, `allChoose.js`).
+- [ ] **Réserve** : pièces en attente, déploiement.
+- [ ] **Échanges** entre camps.
+- [ ] **Commando**, **Bombe H** — règles complètes.
+- [ ] Résolution combat fidèle au legacy (pas seulement somme des forces).
+- [ ] Phases distinctes planification / résolution en UI.
+
+#### Interface
+
+- [ ] Plateau visuel (carte, tokens, assets `Assets/Textures/`).
+- [ ] UI bataille remplaçant `infoButtons.js` / `playerTurn.js`.
+- [ ] Tutoriel jouable (contenu depuis `ScriptMenu/Tutorial.js`).
+- [ ] Options : persistance volumes, plein écran.
+- [ ] Animations / SFX (`Assets/Sound/`).
+
+#### IA
+
+- [ ] Équilibrage fin vs `ScriptIA_*.js` (~23k lignes × 3) si nécessaire.
+- [ ] IA mer / air / achats Power / bombes.
+
+#### Multijoueur
+
+- [ ] Remplacement UNet Unity (WebSocket / ENet / Godot multiplayer) — écran « joueur réseau » déjà prévu dans `GameSession`.
+
+#### Qualité
+
+- [ ] Tests unitaires GDScript supplémentaires (combat, Power, graphes mer/air).
+- [ ] Export mobile (Android / iOS) — cible historique Google Play (`com.QD.Forc2`).
+
+### Notes techniques
+
+- Godot **4.6.3** ; binaire console Windows : chemin dans `tools/godot.env` (local, gitignored).
+- Legacy Unity inchangé sous `Assets/` — référence pour parsers et règles.
+- Ce changelog ne documente pas le dépôt Unity d’origine ; uniquement l’avancement du client Godot.

godot/README.md

@@ -0,0 +1,78 @@
+# Forces — Godot 4
+
+Portage du jeu **Forces** (Unity / JavaScript, stage 42, 2013) vers **Godot 4.6** (4.x compatible).
+
+Le dépôt Unity d’origine reste à la racine (`Assets/`, etc.). Ce dossier est le client Godot autonome.
+
+## Branche
+
+Développement sur `godot4-port`.
+
+## Ouvrir le projet
+
+1. Installer [Godot 4.6](https://godotengine.org/download) (ou la version que tu utilises déjà).
+2. Importer le dossier `godot/` comme projet.
+## Flux joueur
+
+1. **Menu** — Jouer / Partie rapide / Tutoriel / Options / Quitter  
+2. **Créer partie** — Vert = vous ; Bleu/Rouge/Jaune = IA ou joueur (+ difficulté IA)  
+3. **Bataille** — planification des ordres (moteur actuel)
+
+F5 démarre sur le **menu principal**.
+
+## Tests headless (CLI / CI / agent)
+
+Sans ouvrir l’éditeur, pour vérifier compilation + moteur :
+
+```powershell
+cd godot
+# Une fois Godot installé, optionnel :
+$env:GODOT_BIN = "C:\Users\tom\Downloads\Godot_v4.6.3-stable_win64.exe"
+.\tools\run_headless.ps1          # smoke (défaut)
+.\tools\run_headless.ps1 compile  # charge le projet 3 frames
+.\tools\run_headless.ps1 import   # importe les assets
+```
+
+Linux/macOS :
+
+```bash
+cd godot
+export GODOT_BIN=/path/to/godot
+./tools/run_headless.sh smoke
+```
+
+Équivalent manuel :
+
+```bash
+godot --headless --path . "res://scenes/headless_test.tscn"
+godot --headless --path . "res://scenes/menu/main_menu.tscn" --quit-after 2
+```
+
+Le workflow GitHub `.github/workflows/godot-headless.yml` lance les mêmes checks sur push `godot/**`.
+
+## Architecture
+
+| Dossier | Rôle |
+|---------|------|
+| `scenes/menu/` | Menu principal, config partie, options, tutoriel |
+| `scenes/battle/` | Écran de bataille (ex-UI debug) |
+| `scripts/app/game_session.gd` | Autoload — config persistée menu → bataille |
+| `scripts/core/` | Moteur sans UI |
+| `data/land_adjacency.json` | Graphe terrestre |
+
+## Roadmap
+
+Voir [`CHANGELOG.md`](CHANGELOG.md) pour le détail daté.
+
+1. ~~**Moteur terrestre**~~ — état, ordres multi-camps, résolution simplifiée, capture drapeau
+2. ~~**Menus & flux**~~ — menu → config → bataille
+3. ~~**IA basique**~~ — `ai_planner.gd` (Facile/Normal/Difficile)
+4. **Mer / air** — parsers `Dep_mer.js` / `Dep_air.js`
+5. **Plateau visuel** — assets Unity / JP
+6. **Règles Power** — jetons, réserve, échanges, bombes H
+7. **UI bataille** — remplacement `infoButtons.js` / `playerTurn.js`
+8. **Multijoueur** — WebSocket / ENet
+
+## Legacy Unity
+
+Référence : `../Assets/Scripts/`