feat: restaure l'éditeur map et ajoute les personnages

.agent/skills/managers.md

@@ -15,12 +15,9 @@ export class SomeManager {
     return SomeManager._instance;
   }
 
-  private constructor() {
-    // init logic
-  }
+  private constructor() {}
 
   destroy(): void {
-    // cleanup logic
     SomeManager._instance = null;
   }
 }
@@ -28,43 +25,12 @@ export class SomeManager {
 
 ## Managers in this project
 
-| Manager              | File                                 | Role                                                                          |
-| -------------------- | ------------------------------------ | ----------------------------------------------------------------------------- |
-| `AudioManager`       | `src/managers/AudioManager.ts`       | Music and SFX playback.                                                       |
-| `InteractionManager` | `src/managers/InteractionManager.ts` | Focus, nearby, trigger, grab, and hand-grab interaction state.                |
-| `GameManager`        | target-state only                    | Future single source of truth for phase, zone, mission, input lock, dialogue. |
-| `CinematicManager`   | target-state only                    | Future GSAP timeline orchestrator.                                            |
-| `ZoneManager`        | target-state only                    | Future zone entry/exit detection and LOD triggers.                            |
+| Manager              | File                                 | Role                                                           |
+| -------------------- | ------------------------------------ | -------------------------------------------------------------- |
+| `AudioManager`       | `src/managers/AudioManager.ts`       | Music and SFX playback.                                        |
+| `InteractionManager` | `src/managers/InteractionManager.ts` | Focus, nearby, trigger, grab, and hand-grab interaction state. |
 
-## Target-State GameManager
-
-`GameManager` does not exist in the current implementation. The following pattern is target-state guidance only and should not be applied until the manager exists in code.
-
-```ts
-export class GameManager {
-  cinematic!: CinematicManager;
-  audio!: AudioManager;
-  zone!: ZoneManager;
-
-  private constructor() {
-    this.cinematic = CinematicManager.getInstance();
-    this.audio = AudioManager.getInstance();
-    this.zone = ZoneManager.getInstance();
-  }
-}
-```
-
-When a `GameManager` exists, components and hooks should access other managers through it:
-
-```ts
-// Correct
-GameManager.getInstance().cinematic.play("intro");
-
-// Wrong — never import sub-managers directly in components
-CinematicManager.getInstance().play("intro");
-```
-
-## Target-State Subscribe Pattern
+## Subscribe Pattern
 
 ```ts
 private listeners = new Set<() => void>()
@@ -79,28 +45,26 @@ private emit(): void {
 }
 ```
 
-In that target-state manager, every `set*()` method calls `this.emit()` to notify subscribers.
+Managers that expose state to React call `this.emit()` from every `set*()` method that changes subscribed state.
 
-## Target-State React Bridge Hook
+## React Bridge Hook
 
 ```ts
-// hooks/useGameState.ts
-export function useGameState() {
-  const game = GameManager.getInstance();
-  const [state, setState] = useState(game.getState());
+// hooks/interaction/useInteraction.ts
+const manager = InteractionManager.getInstance();
 
-  useEffect(() => {
-    return game.subscribe(() => setState({ ...game.getState() }));
-  }, [game]);
-
-  return state;
+export function useInteraction(): InteractionSnapshot {
+  return useSyncExternalStore(
+    manager.subscribe.bind(manager),
+    manager.getState.bind(manager),
+  );
 }
 ```
 
 ## Rules
 
 - Do not add a `GameManager` unless the feature requires a real shared gameplay state owner.
-- Current managers may be imported directly until the target-state orchestrator exists.
+- Current managers may be imported directly.
 - Keep singleton managers limited to side-effect services or shared interaction state.
 - Always call `destroy()` on cleanup when a manager owns external resources.
 - Never create manager instances with `new` — always use `.getInstance()`.

.gitattributes

@@ -23,3 +23,6 @@
 # Video (cinematics)
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+
+# ML models
+*.task filter=lfs diff=lfs merge=lfs -text

.github/workflows/quality.yml

@@ -69,6 +69,12 @@ jobs:
       - name: 📥 Install
         run: npm ci
 
+      - name: 🧹 Lint
+        run: npm run lint
+
+      - name: 🎨 Format check
+        run: npm run format:check
+
       - name: 📦 Build
         run: npm run build
 
@@ -78,7 +84,6 @@ jobs:
           SIZE=$(du -k dist/assets | cut -f1)
           echo "Bundle size: ${SIZE}KB"
 
-          # Threshold: 5000KB (configurable)
           THRESHOLD=5000
 
           if [ "$SIZE" -gt "$THRESHOLD" ]; then

GAME_FLOW.md

@@ -1,164 +0,0 @@
-# Game Flow - La Fabrik
-
-## Étapes du jeu
-
-```
-intro → start-intro → naming → bienvenue → star-move → mission2 → searching_problem → preparation → outOfFabrik
-```
-
----
-
-## Détail des étapes
-
-### 1. `intro` (initial)
-
-- État initial au chargement du jeu
-- Aucune action, juste une étape de départ
-- Transition automatique vers `start-intro`
-
-### 2. `start-intro`
-
-- **Déclenchement** : Auto-transition depuis `intro` quand la scène est chargée
-- **Action** : Joue l'audio d'intro (`intro`)
-- **Attente** : Attend que l'audio se termine
-- **Transition** : Vers `naming` quand l'audio se termine
-
-### 3. `naming`
-
-- **Déclenchement** : Quand l'audio d'intro se termine
-- **Action** : Affiche un input pour demander le prénom du joueur
-- **Attente** : L'utilisateur entre son prénom et valide
-- **Transition** : Vers `bienvenue` quand l'utilisateur valide
-
-### 4. `bienvenue`
-
-- **Déclenchement** : Quand l'utilisateur valide son prénom
-- **Actions** :
-  - Affiche "Bienvenue {prénom} !" à l'écran
-  - Joue l'audio de bienvenue
-- **Attente** : Attend que l'audio se termine
-- **Transition** : Vers `star-move` quand l'audio se termine
-
-### 5. `star-move`
-
-- **Déclenchement** : Quand l'audio de bienvenue se termine
-- **Action** : Active le mouvement du joueur (`setCanMove(true)`)
-- **État** : Le joueur peut maintenant se déplacer librement
-- **Zone** : La détection de zone devient active (ZoneDetection)
-
-### 6. `mission2`
-
-- **Déclenchement** : Quand le joueur entre dans la zone `fabrikExit` (position: `[-5, 25, -15]`)
-- **Actions** :
-  - Stocke `activityCity: false` dans le store Zustand
-  - Joue l'audio `alertCentral`
-- **État** : Les systèmes lisent `activityCity` depuis `useGameStore` pour adapter leur comportement
-- **Attente** : Le joueur atteint la zone de trigger pour `searching_problem`
-
-### 7. `searching_problem`
-
-- **Déclenchement** : Quand le joueur entre dans la zone `searchingProblemZone` (position: `[-5, 25, -30]`)
-- **Actions** :
-  - Joue l'audio `searchingProblem`
-  - Affiche l'objet "central" (position: `[1, 15, -45]`)
-- **Attente** : Le joueur interagit avec l'objet "central"
-
-### 8. `preparation`
-
-- **Déclenchement** : Quand le joueur interagit avec l'objet "central"
-- **Actions** :
-  - Bloque le mouvement (`setCanMove(false)`)
-  - Cache l'objet "central"
-
-### 9. `outOfFabrik`
-
-- **Déclenchement** : (non implémenté pour le moment)
-- **Action** : Transition vers l'étape finale
-
----
-
-## Fichiers clés
-
-| Fichier                                 | Rôle                                                      |
-| --------------------------------------- | --------------------------------------------------------- |
-| `src/managers/stores/useGameStore.ts`   | Store Zustand pour l'état global du jeu                   |
-| `src/components/game/GameFlow.tsx`      | Gère les transitions automatiques et la lecture audio     |
-| `src/components/ui/IntroUI.tsx`         | Affiche l'input pour le prénom et le message de bienvenue |
-| `src/components/zone/ZoneDetection.tsx` | Détecte quand le joueur entre dans une zone               |
-| `src/world/GameStageContent.tsx`        | Monte les contenus de mission dans la scène               |
-| `src/data/audioConfig.ts`               | Chemins des fichiers audio                                |
-| `src/data/zones.ts`                     | Configuration des zones de transition                     |
-
----
-
-## Configuration audio
-
-```typescript
-// src/data/audioConfig.ts
-export const AUDIO_PATHS = {
-  intro: "/sounds/fa.mp3",
-  bienvenue: "/sounds/fa.mp3",
-  alertCentral: "/sounds/fa.mp3",
-  searchingProblem: "/sounds/fa.mp3",
-};
-```
-
----
-
-## Configuration des zones
-
-```typescript
-// src/data/zones.ts
-export const ZONES: Zone[] = [
-  {
-    id: "fabrikExit",
-    position: [-5, 25, -15],
-    radius: 10,
-    height: 20,
-    targetStep: "mission2",
-  },
-  {
-    id: "searchingProblemZone",
-    position: [-5, 25, -30],
-    radius: 10,
-    height: 20,
-    targetStep: "searching_problem",
-  },
-];
-```
-
----
-
-## Store Zustand
-
-```typescript
-// src/managers/stores/useGameStore.ts
-interface GameState {
-  mainState: MainGameState;
-  missionFlow: {
-    activityCity: boolean;
-    canMove: boolean;
-    playerName: string;
-  };
-}
-```
-
----
-
-## Debug
-
-En mode debug (`?debug` dans l'URL), on peut voir :
-
-- **Game Step** : L'étape actuelle dans le panneau lil-gui
-- **Player Position** : Position X, Y, Z du joueur en temps réel
-- **Zone Visualization** : Anneaux visuels au sol pour les zones + cylindres transparents
-
----
-
-## Notes techniques
-
-- Le mouvement du joueur est bloqué tant que `canMove` est `false`
-- Le store Zustand (`useGameStore`) est la source principale de vérité
-- `GameStepManager` synchronise automatiquement avec le store Zustand lors des transitions
-- Les transitions via les zones utilisent `GameStepManager.transitionTo()` qui met à jour le store
-- L'audio utilise un callback `onEnded` pour déclencher les transitions automatiques

README.md

@@ -10,7 +10,7 @@ The current prototype puts the player in a repair-oriented world where they prog
 - Production map loaded from `public/map.json`
 - Progressive map/model/collision/stage loading overlay
 - Player controller with pointer lock, `ZQSD` movement, jump, octree collision, trigger input, and grab input
-- Reusable repair-game flow for `bike`, `pylone`, and `ferme`
+- Reusable repair-game flow for `ebike`, `pylon`, and `farm`
 - Repair case animation, exploded model scan, broken-part markers, grabbable replacements, snap-to-placeholder placement, install validation, reassembly, and completion
 - Shared interaction system for trigger and grab objects
 - Rapier physics for gameplay objects while the player keeps a Three.js octree collision controller
@@ -18,7 +18,7 @@ The current prototype puts the player in a repair-oriented world where they prog
 - Category-based audio manager for music, SFX, and dialogue
 - Dialogue manifest, SRT subtitles, subtitle overlay, and dialogue queueing
 - Cinematic manifest with GSAP camera keyframes and optional dialogue cues
-- In-game settings menu for volumes, subtitles, subtitle language, and the currently staged repair-runtime toggle
+- In-game settings menu for volumes, subtitles, and subtitle language
 - Debug mode with `?debug`, lil-gui controls, game-state panel, hand-tracking panel, debug camera, physics playground, and R3F perf
 - `/editor` route for map transforms, SRT editing, dialogue manifest editing, cinematic manifest editing, preview, validation, export, and dev-server saves
 - `/docs` route that renders the repository documentation inside the app
@@ -112,7 +112,7 @@ npm run build
 
 ## Optional Hand-Tracking Backend
 
-The app can use browser-side MediaPipe, but the default debug source is the local backend.
+The app can use the local Python backend, but the default debug source is browser-side MediaPipe.
 
 ```bash
 python3.11 -m venv backend/.venv
@@ -154,8 +154,7 @@ WS  ws://localhost:8000/ws
 ## Current Caveats
 
 - This is still a prototype, not a complete game runtime.
-- The repair-runtime toggle is stored in settings and displayed in the UI, but the repair game currently still runs locally in React/Three.
-- `useRepairMovementLocked()` currently returns `false`, so the movement-lock rule and indicator are present but disabled on `develop`.
+- `useRepairMovementLocked()` locks player movement during focused repair steps and drives the repair movement indicator.
 - Production editor persistence does not exist. Save endpoints in `vite.config.ts` are local Vite dev-server helpers.
 - The player uses octree collision while gameplay objects use Rapier. Keep that boundary deliberate unless the whole player controller is migrated.
 

docs/code-review-preparation.md

@@ -19,7 +19,7 @@ La-Fabrik est une expérience web 3D en React, Vite, Three.js et React Three Fib
 Le joueur est dans un monde 3D et avance dans une progression de réparation :
 
 ```txt
-intro -> bike -> pylone -> ferme -> outro
+intro -> ebike -> pylon -> farm -> outro
 ```
 
 Les trois piliers à connaître pour la review :
@@ -62,7 +62,7 @@ HomePage
     -> World
       -> GameMap
       -> GameStageContent
-        -> RepairGame bike/pylone/ferme
+        -> RepairGame ebike/pylon/farm
       -> GameMusic
       -> GameDialogues
       -> Player
@@ -324,7 +324,7 @@ Ouvrir dans cet ordre :
 `RepairGame` reçoit une mission :
 
 ```tsx
-<RepairGame mission="bike" position={[8, 0, -6]} />
+<RepairGame mission="ebike" position={[42.2399, 4.5484, 34.6468]} />
 ```
 
 Puis il vérifie :
@@ -347,7 +347,7 @@ Les variations mission sont dans `repairMissions.ts` :
 ### Pourquoi c'est bien
 
 - Un seul flow réutilisable.
-- Moins de duplication entre `bike`, `pylone`, `ferme`.
+- Moins de duplication entre `ebike`, `pylon`, `farm`.
 - Les règles générales restent dans les composants.
 - Les variations restent dans la data.
 - Le debug panel peut tester les mêmes steps que le vrai jeu.
@@ -471,9 +471,9 @@ Main states :
 
 ```txt
 intro
-bike
-pylone
-ferme
+ebike
+pylon
+farm
 outro
 ```
 

docs/technical/animation.md

@@ -46,7 +46,7 @@ It supports:
 The debug physics scene currently uses it to preview:
 
 ```txt
-public/models/electricienne_animated/model.gltf
+public/models/electricienne-animated/model.gltf
 ```
 
 with the `Dance` animation.

docs/technical/architecture.md

@@ -107,7 +107,7 @@ It owns:
 
 - `mainState`
 - intro state
-- `bike`, `pylone`, and `ferme` mission state
+- `ebike`, `pylon`, and `farm` mission state
 - outro state
 - `isCinematicPlaying`
 - progression actions
@@ -297,8 +297,7 @@ public/models/{name}/model.gltf
 - The repository is still a prototype.
 - There is no central production `GameManager`.
 - The repair game is implemented, but broader mission orchestration is still light.
-- `useRepairMovementLocked()` currently returns `false`, so repair movement lock is disabled even though the rule and UI component exist.
-- The repair-runtime setting is stored in settings but not consumed by the repair-game implementation.
+- `useRepairMovementLocked()` locks player movement during focused repair steps.
 - Player collision and Rapier gameplay physics are separate systems.
 - Editor persistence is local development tooling only.
 - Debug systems are still part of active scene composition and should remain easy to identify.

docs/technical/editor.md

@@ -122,8 +122,7 @@ If `model.glb` and `model.gltf` are both missing, the editor renders a fallback
 - Click: select a node.
 - `Shift` + right click: add or remove a node from the multi-selection.
 - `Esc`: clear selection.
-- Click empty space: clear selection.
-- Selection lock button: prevent object clicks, empty-space clicks, and `Esc` from changing the current selection.
+- Selection lock button: prevent object clicks and `Esc` from changing the current selection.
 - Selection clear button: intentionally clear the current selection even when the lock is active.
 - `T`: translate mode.
 - `R`: rotate mode.
@@ -190,9 +189,9 @@ The state is passed to:
 
 - `EditorControls`, to render the lock/unlock button
 - `EditorScene`, to block `Esc` deselection when locked
-- `EditorMap`, to block object selection and empty-space deselection when locked
+- `EditorMap`, to block object selection when locked
 
-The clear button calls `onClearSelection` directly from `EditorControls`. This is intentionally separate from scene click behavior so the user always has an explicit way to clear the selection.
+The clear button calls `onClearSelection` directly from `EditorControls`. Clicking empty canvas space does not clear the current selection; use `Esc` or the explicit clear button instead.
 
 ## Dialogue SRT Editing
 

docs/technical/game-flow.md

@@ -1,164 +0,0 @@
-# Game Flow - La Fabrik
-
-## Étapes du jeu
-
-```
-intro → start-intro → naming → bienvenue → star-move → mission2 → searching_problem → preparation → outOfFabrik
-```
-
----
-
-## Détail des étapes
-
-### 1. `intro` (initial)
-
-- État initial au chargement du jeu
-- Aucune action, juste une étape de départ
-- Transition automatique vers `start-intro`
-
-### 2. `start-intro`
-
-- **Déclenchement** : Auto-transition depuis `intro` quand la scène est chargée
-- **Action** : Joue l'audio d'intro (`intro`)
-- **Attente** : Attend que l'audio se termine
-- **Transition** : Vers `naming` quand l'audio se termine
-
-### 3. `naming`
-
-- **Déclenchement** : Quand l'audio d'intro se termine
-- **Action** : Affiche un input pour demander le prénom du joueur
-- **Attente** : L'utilisateur entre son prénom et valide
-- **Transition** : Vers `bienvenue` quand l'utilisateur valide
-
-### 4. `bienvenue`
-
-- **Déclenchement** : Quand l'utilisateur valide son prénom
-- **Actions** :
-  - Affiche "Bienvenue {prénom} !" à l'écran
-  - Joue l'audio de bienvenue
-- **Attente** : Attend que l'audio se termine
-- **Transition** : Vers `star-move` quand l'audio se termine
-
-### 5. `star-move`
-
-- **Déclenchement** : Quand l'audio de bienvenue se termine
-- **Action** : Active le mouvement du joueur (`setCanMove(true)`)
-- **État** : Le joueur peut maintenant se déplacer librement
-- **Zone** : La détection de zone devient active (ZoneDetection)
-
-### 6. `mission2`
-
-- **Déclenchement** : Quand le joueur entre dans la zone `fabrikExit` (position: `[-5, 25, -15]`)
-- **Actions** :
-  - Stocke `activityCity: false` dans le store Zustand
-  - Joue l'audio `alertCentral`
-- **État** : Les systèmes lisent `activityCity` depuis `useGameStore` pour adapter leur comportement
-- **Attente** : Le joueur atteint la zone de trigger pour `searching_problem`
-
-### 7. `searching_problem`
-
-- **Déclenchement** : Quand le joueur entre dans la zone `searchingProblemZone` (position: `[-5, 25, -30]`)
-- **Actions** :
-  - Joue l'audio `searchingProblem`
-  - Affiche l'objet "central" (position: `[1, 15, -45]`)
-- **Attente** : Le joueur interagit avec l'objet "central"
-
-### 8. `preparation`
-
-- **Déclenchement** : Quand le joueur interagit avec l'objet "central"
-- **Actions** :
-  - Bloque le mouvement (`setCanMove(false)`)
-  - Cache l'objet "central"
-
-### 9. `outOfFabrik`
-
-- **Déclenchement** : (non implémenté pour le moment)
-- **Action** : Transition vers l'étape finale
-
----
-
-## Fichiers clés
-
-| Fichier                                 | Rôle                                                      |
-| --------------------------------------- | --------------------------------------------------------- |
-| `src/managers/stores/useGameStore.ts`   | Store Zustand pour l'état global du jeu                   |
-| `src/components/game/GameFlow.tsx`      | Gère les transitions automatiques et la lecture audio     |
-| `src/components/ui/IntroUI.tsx`         | Affiche l'input pour le prénom et le message de bienvenue |
-| `src/components/zone/ZoneDetection.tsx` | Détecte quand le joueur entre dans une zone               |
-| `src/world/GameStageContent.tsx`        | Monte les contenus de mission dans la scène               |
-| `src/data/audioConfig.ts`               | Chemins des fichiers audio                                |
-| `src/data/zones.ts`                     | Configuration des zones de transition                     |
-
----
-
-## Configuration audio
-
-```typescript
-// src/data/audioConfig.ts
-export const AUDIO_PATHS = {
-  intro: "/sounds/fa.mp3",
-  bienvenue: "/sounds/fa.mp3",
-  alertCentral: "/sounds/fa.mp3",
-  searchingProblem: "/sounds/fa.mp3",
-};
-```
-
----
-
-## Configuration des zones
-
-```typescript
-// src/data/zones.ts
-export const ZONES: Zone[] = [
-  {
-    id: "fabrikExit",
-    position: [-5, 25, -15],
-    radius: 10,
-    height: 20,
-    targetStep: "mission2",
-  },
-  {
-    id: "searchingProblemZone",
-    position: [-5, 25, -30],
-    radius: 10,
-    height: 20,
-    targetStep: "searching_problem",
-  },
-];
-```
-
----
-
-## Store Zustand
-
-```typescript
-// src/managers/stores/useGameStore.ts
-interface GameState {
-  mainState: MainGameState;
-  missionFlow: {
-    activityCity: boolean;
-    canMove: boolean;
-    playerName: string;
-  };
-}
-```
-
----
-
-## Debug
-
-En mode debug (`?debug` dans l'URL), on peut voir :
-
-- **Game Step** : L'étape actuelle dans le panneau lil-gui
-- **Player Position** : Position X, Y, Z du joueur en temps réel
-- **Zone Visualization** : Anneaux visuels au sol pour les zones + cylindres transparents
-
----
-
-## Notes techniques
-
-- Le mouvement du joueur est bloqué tant que `canMove` est `false`
-- Le store Zustand (`useGameStore`) est la source principale de vérité
-- `GameStepManager` synchronise automatiquement avec le store Zustand lors des transitions
-- Les transitions via les zones utilisent `GameStepManager.transitionTo()` qui met à jour le store
-- L'audio utilise un callback `onEnded` pour déclencher les transitions automatiques

docs/technical/hand-tracking.md

@@ -32,7 +32,7 @@ This keeps hand tracking active while the player is inside an interaction zone,
 
 The production repair activation conditions are:
 
-- active `mainState` is `bike`, `pylone`, or `ferme`
+- active `mainState` is `ebike`, `pylon`, or `farm`
 - the active mission step is `inspected`, `repairing`, `reassembling`, or `done`
 
 This keeps the webcam off during `waiting`, `fragmented`, and `scanning`, then enables hand input only when the repair flow is expected to use hands.

docs/technical/interaction.md

@@ -184,7 +184,7 @@ Input is ignored while:
 - the settings menu is open
 - a cinematic is playing
 
-Movement lock is read separately from `useRepairMovementLocked`, but that hook currently returns `false` on this branch.
+Movement lock is read separately from `useRepairMovementLocked`, which locks the player during focused repair steps.
 
 ## UI Prompt
 

docs/technical/mission-flow.md

@@ -37,7 +37,7 @@ Mission progression is not owned by a manager. Components update the store throu
 
 - `src/components/game/GameFlow.tsx` reacts to `missionFlow.step` and triggers one-off side effects such as intro audio and movement unlocks.
 - `src/components/zone/ZoneDetection.tsx` reads the camera position and moves the flow to a target step when the player enters a configured zone.
-- `src/components/three/interaction/CentralObject.tsx` and `VillageoisHelperObject.tsx` expose temporary interactive mission objects.
+- `src/world/GameStageContent.tsx` mounts repair games and their mission-start triggers.
 - `src/pages/page.tsx` mounts mission HTML overlays: `IntroUI`, `BienvenueDisplay`, and `DialogMessage`.
 - `src/world/player/PlayerController.tsx` reads `missionFlow.canMove` as an additional movement lock.
 

docs/technical/repair-game.md

@@ -8,11 +8,11 @@ The repair game is the current core gameplay loop. It gives three missions the s
 
 Implemented missions:
 
-| Mission  | Object        | Role                                          |
-| -------- | ------------- | --------------------------------------------- |
-| `bike`   | E-bike        | Repair a damaged cooling core                 |
-| `pylone` | Power pylon   | Restore relay/panel-like broken parts         |
-| `ferme`  | Vertical farm | Stabilize irrigation/sensor-like broken parts |
+| Mission | Object        | Role                                          |
+| ------- | ------------- | --------------------------------------------- |
+| `ebike` | E-bike        | Repair a damaged cooling core                 |
+| `pylon` | Power pylon   | Restore relay/panel-like broken parts         |
+| `farm`  | Vertical farm | Stabilize irrigation/sensor-like broken parts |
 
 ## Main Files
 
@@ -79,7 +79,7 @@ src/managers/stores/useGameStore.ts
 - `setMissionStep(mission, nextStep)`
 - `completeMission(mission)`
 
-The important architectural choice is that reusable repair components do not call `setBikeState`, `setPyloneState`, or `setFermeState` directly. They use generic mission actions so the same component can run for all three missions.
+The important architectural choice is that reusable repair components do not call `setEbikeState`, `setPylonState`, or `setFarmState` directly. They use generic mission actions so the same component can run for all three missions.
 
 ## Data-Driven Mission Config
 
@@ -159,7 +159,7 @@ The repair case appears near the mission object. The player can:
 
 Both paths move to `fragmented`.
 
-Important current detail: `useRepairMovementLocked()` currently returns `false`, so the movement-lock rule and indicator are present but disabled in the current branch.
+`useRepairMovementLocked()` locks player movement during focused repair steps and drives the repair movement indicator.
 
 ### Fragmented
 
@@ -324,9 +324,9 @@ src/world/GameStageContent.tsx
 Current positions:
 
 ```tsx
-<RepairGame mission="bike" position={[8, 0, -6]} />
-<RepairGame mission="pylone" position={[64, 0, -66]} />
-<RepairGame mission="ferme" position={[-24, 0, 42]} />
+<RepairGame mission="ebike" position={[42.2399, 4.5484, 34.6468]} />
+<RepairGame mission="pylon" position={[64, 0, -66]} />
+<RepairGame mission="farm" position={[-24, 0, 42]} />
 ```
 
 Only the repair game whose `mission` matches `useGameStore().mainState` renders active content.

docs/technical/zustand.md

@@ -28,11 +28,11 @@ They are under `src/managers/stores/` because they are shared runtime state, not
 
 ## Store Responsibilities
 
-| Store              | Responsibility                                                    |
-| ------------------ | ----------------------------------------------------------------- |
-| `useGameStore`     | Durable game progression, mission steps, cinematic input lock     |
-| `useSettingsStore` | Menu visibility, volumes, subtitle options, repair-runtime toggle |
-| `useSubtitleStore` | Currently displayed subtitle cue                                  |
+| Store              | Responsibility                                                |
+| ------------------ | ------------------------------------------------------------- |
+| `useGameStore`     | Durable game progression, mission steps, cinematic input lock |
+| `useSettingsStore` | Menu visibility, volumes, and subtitle options                |
+| `useSubtitleStore` | Currently displayed subtitle cue                              |
 
 ## Managers vs Stores
 
@@ -65,18 +65,18 @@ Main states:
 | Main state | Role                            |
 | ---------- | ------------------------------- |
 | `intro`    | Onboarding and opening sequence |
-| `bike`     | E-bike repair sequence          |
-| `pylone`   | Power pylon repair sequence     |
-| `ferme`    | Vertical farm repair sequence   |
+| `ebike`    | E-bike repair sequence          |
+| `pylon`    | Power pylon repair sequence     |
+| `farm`     | Vertical farm repair sequence   |
 | `outro`    | Ending sequence                 |
 
 Other important state:
 
 - `isCinematicPlaying`
 - `intro`
-- `bike`
-- `pylone`
-- `ferme`
+- `ebike`
+- `pylon`
+- `farm`
 - `outro`
 
 Mission steps:
@@ -125,28 +125,28 @@ For development and debug tooling, direct setters also exist:
 ```ts
 const setMainState = useGameStore((state) => state.setMainState);
 
-setMainState("bike");
+setMainState("ebike");
 ```
 
 Direct setters are useful for debug panels, but production gameplay should prefer business actions such as:
 
 - `advanceGameState`
-- `completeBike`
-- `completePylone`
-- `completeFerme`
+- `completeEbike`
+- `completePylon`
+- `completeFarm`
 - `completeMission`
 
-Mission gameplay that can target `bike`, `pylone`, or `ferme` should prefer generic mission actions:
+Mission gameplay that can target `ebike`, `pylon`, or `farm` should prefer generic mission actions:
 
 ```ts
 const setMissionStep = useGameStore((state) => state.setMissionStep);
 const completeMission = useGameStore((state) => state.completeMission);
 
-setMissionStep("bike", "inspected");
-completeMission("bike");
+setMissionStep("ebike", "inspected");
+completeMission("ebike");
 ```
 
-This keeps reusable gameplay components such as `RepairGame` from duplicating mission-specific branches like `setBikeState`, `setPyloneState`, and `setFermeState`.
+This keeps reusable gameplay components such as `RepairGame` from duplicating mission-specific branches like `setEbikeState`, `setPylonState`, and `setFarmState`.
 
 ## Settings Store
 
@@ -188,9 +188,9 @@ State/actions:
 Current production repair placement:
 
 ```tsx
-<RepairGame mission="bike" position={[8, 0, -6]} />
-<RepairGame mission="pylone" position={[64, 0, -66]} />
-<RepairGame mission="ferme" position={[-24, 0, 42]} />
+<RepairGame mission="ebike" position={[42.2399, 4.5484, 34.6468]} />
+<RepairGame mission="pylon" position={[64, 0, -66]} />
+<RepairGame mission="farm" position={[-24, 0, 42]} />
 ```
 
 `RepairGame` reads the active mission step from the store and writes transitions through generic actions such as `setMissionStep` and `completeMission`.

docs/user/editor.md

@@ -72,7 +72,7 @@ Use the trash button in `Selection` to delete the selected node from the map tre
 | -------------------- | -------------------------- |
 | Select object        | Click object               |
 | Toggle multi-select  | `Shift` + right click      |
-| Deselect             | `Esc` or click empty space |
+| Deselect             | `Esc`                      |
 | Lock selection       | `Lock` button in Selection |
 | Clear selection      | `X` button in Selection    |
 | Translate mode       | `T`                        |
@@ -91,7 +91,7 @@ The `Selection` section shows the selected object name and its index in `public/
 - Click an object to select it.
 - Use `Shift + right click` on objects to add or remove them from a multi-selection.
 - When several objects are selected, the gizmo appears on the selection group and applies translate, rotate, or scale to each selected node.
-- Click empty space or press `Esc` to clear the selection.
+- Press `Esc` to clear the selection.
 - Use the `X` button to clear the selection explicitly.
 - Use the `Lock` button to protect the current selection while editing.
 - Use the scale fields to edit X/Y/Z scale precisely.
@@ -108,7 +108,6 @@ This is intended for map objects that should sit on the ground. Disable it when
 When selection is locked:
 
 - clicking another object does not change the selection
-- clicking empty space does not clear the selection
 - pressing `Esc` does not clear the selection
 - the `X` button still clears the selection intentionally
 

docs/user/features.md

@@ -37,7 +37,7 @@ This document lists the user-visible and developer-facing features implemented i
 - Input lock while the settings menu is open
 - Input lock while a cinematic is playing
 - Octree collision against dedicated map collision nodes, currently scoped to the `terrain` node
-- Repair movement-lock hook and indicator exist, but the hook currently returns `false`, so movement is not locked during repair on the current branch
+- Repair movement lock during focused repair steps, with a matching UI indicator
 
 ## Physics And Collision
 
@@ -63,12 +63,12 @@ This document lists the user-visible and developer-facing features implemented i
 
 ## Repair Gameplay
 
-- Reusable `RepairGame` mounted for `bike`, `pylone`, and `ferme`
+- Reusable `RepairGame` mounted for `ebike`, `pylon`, and `farm`
 - Mission progression driven by Zustand and shared `MissionStep` types
 - Production repair positions:
-  - `bike` at `[8, 0, -6]`
-  - `pylone` at `[64, 0, -66]`
-  - `ferme` at `[-24, 0, 42]`
+  - `ebike` at `[42.2399, 4.5484, 34.6468]`
+  - `pylon` at `[64, 0, -66]`
+  - `farm` at `[-24, 0, 42]`
 - Debug physics repair playground zones for all three missions
 - Data-driven mission config in `src/data/gameplay/repairMissions.ts`
 - Mission flow: `locked -> waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done`
@@ -95,7 +95,7 @@ This document lists the user-visible and developer-facing features implemented i
 ## Game Progression Store
 
 - Zustand `useGameStore` for durable gameplay progression
-- Main states: `intro`, `bike`, `pylone`, `ferme`, `outro`
+- Main states: `intro`, `ebike`, `pylon`, `farm`, `outro`
 - Per-mission repair step state
 - Per-mission completion flags
 - Generic mission helpers: `setMissionStep`, `completeMission`, `advanceGameState`, `rewindGameState`, `resetGame`
@@ -108,12 +108,11 @@ This document lists the user-visible and developer-facing features implemented i
 - Music, SFX, and dialogue volume sliders
 - Subtitle visibility toggle
 - Subtitle language choice between French and English
-- Repair-runtime choice between JavaScript and Python modes stored in settings
 - Quit action that clears browser-accessible cookies and returns to `/`
 - Crosshair overlay
 - Interaction prompt
 - Subtitle overlay
-- Repair movement-lock indicator component, currently inactive because the lock hook returns `false`
+- Repair movement-lock indicator
 - Debug overlay layout
 - Scene loading overlay
 
@@ -192,7 +191,7 @@ This document lists the user-visible and developer-facing features implemented i
 - Debug game-state panel
 - Debug hand-tracking panel
 - Physics test scene with floor, grabbable object, trigger object, repair zones, and animated model preview
-- Animated `electricienne_animated` model preview restored in the debug physics scene
+- Animated `electricienne-animated` model preview restored in the debug physics scene
 
 ## Map And Content Editor
 
@@ -230,7 +229,7 @@ This document lists the user-visible and developer-facing features implemented i
 - Technical docs for architecture, scene runtime, repair game, interaction, editor, audio, hand tracking, Zustand, Three debugging, animation, and target architecture
 - User docs for implemented features, main feature, editor usage, and code-review preparation
 
-## Not Implemented Or Incomplete
+## Known Gaps
 
 - Complete production mission manager/orchestrator
 - Full mission HUD or minimap

docs/user/main-feature.md

@@ -8,7 +8,7 @@ The main feature is a reusable repair flow mounted in the production game scene.
 
 The current user flow is:
 
-1. Enter a mission state such as `bike`, `pylone`, or `ferme`.
+1. Enter a mission state such as `ebike`, `pylon`, or `farm`.
 2. Move close to the active repair object in the game scene.
 3. Aim at the object and press the interaction key when prompted.
 4. The mission step moves from `waiting` to `inspected`.
@@ -21,7 +21,7 @@ The current user flow is:
 11. Move each scanned broken part into a compatible placeholder so the damaged parts are stored in the case.
 12. Press `E` on the green install target to move to `reassembling`. Wrong parts turn the target red and cannot finish the repair.
 13. The exploded object animates back into its assembled form with completion particles, then moves to `done`.
-14. Press `E` on the completion target. The repair case closes, returns to the ground, disappears, then `completeMission` moves to the next mission or to `outro` after `ferme`.
+14. Press `E` on the completion target. The repair case closes, returns to the ground, disappears, then `completeMission` moves to the next mission or to `outro` after `farm`.
 
 ## Why It Matters
 
@@ -39,11 +39,11 @@ In `inspected`, `RepairGame` can also move to `fragmented`. Keyboard input goes
 
 In `fragmented`, the repair object is rendered with `ExplodableModel`, then automatically advances to `scanning`. In `scanning`, the exploded model remains visible, a blue scan visual moves from part to part, and a red halo/wire marker plus the configured broken UI video stay attached to configured broken parts after the scanner reaches them. The scan matches configured broken parts by `nodeName` and reports diagnostics when a configured node is missing. In `repairing`, the case opens in a larger focused transform, `RepairCaseModel` traverses the case GLTF for empty nodes named `placeholder_*`, several grabbable replacement parts appear on those slot positions, and releasing a part near a slot snaps it into place with a short GSAP animation. Scanned broken parts are also rendered as grabbable objects and must be deposited into a compatible slot before the final install target validates. If `brokenParts[].caseSlotName` is configured, that broken part snaps only to the matching slot; otherwise it can use any available slot. If the current case asset has no slot nodes, the flow keeps using fallback focus positions and logs the fallback. Replacement parts show green or red placement feedback after snapping, broken parts show stored feedback after deposit, and the install target gives a short blocked feedback if the player tries to validate too early. The install target only validates when the configured correct replacement part is placed and all scanned broken parts have been deposited. In `reassembling`, the exploded model animates back into its assembled position with green completion particles before the flow moves to `done`. In `done`, the repaired object remains visible with a completion target; validating closes the repair case first, then plays the case exit animation before advancing the global mission progression.
 
-The mission config now carries the mission-specific variations. `bike` repairs one cooling core, `pylone` scans and stores both the lamp relay and a damaged panel with slower scan/reassembly timing, and `ferme` scans and stores an irrigation pump plus humidity sensor with faster scan/reassembly timing.
+The mission config now carries the mission-specific variations. `ebike` repairs one cooling core, `pylon` scans and stores both the lamp relay and a damaged panel with slower scan/reassembly timing, and `farm` scans and stores an irrigation pump plus humidity sensor with faster scan/reassembly timing.
 
 ## Key Files
 
-- `src/world/GameStageContent.tsx` mounts production `RepairGame` instances for `bike`, `pylone`, and `ferme`.
+- `src/world/GameStageContent.tsx` mounts production `RepairGame` instances for `ebike`, `pylon`, and `farm`.
 - `src/components/three/gameplay/RepairCompletionStep.tsx` renders the final repaired object, completion target, case exit animation, and mission UI prompt.
 - `src/components/three/gameplay/RepairGame.tsx` composes the reusable production repair flow.
 - `src/components/three/gameplay/RepairBrokenPartHighlight.tsx` renders the red halo and wire marker around detected broken parts during scanning.
@@ -56,16 +56,16 @@ The mission config now carries the mission-specific variations. `bike` repairs o
 - `src/components/three/gameplay/RepairPromptVideo.tsx` renders `.webm` prompts inside the 3D scene.
 - `src/components/three/gameplay/RepairScanSequence.tsx` keeps the exploded model visible and advances the scan from part to part.
 - `src/components/three/gameplay/RepairScanVisual.tsx` renders the scan halo and scan line around the active part.
-- `src/components/ui/RepairMovementLockIndicator.tsx` renders the HTML indicator intended for repair movement lock.
+- `src/components/ui/RepairMovementLockIndicator.tsx` renders the HTML repair movement-lock indicator.
 - `src/hooks/gameplay/useRepairFragmentationInput.ts` handles the `inspected -> fragmented` two-fists input and can optionally bind keyboard input for non-trigger flows.
 - `src/hooks/gameplay/useRepairMissionStep.ts` reads the active mission step from the game store.
-- `src/hooks/gameplay/useRepairMovementLocked.ts` exposes the shared repair movement-lock rule used by the player controller and UI indicator, but currently returns `false`.
+- `src/hooks/gameplay/useRepairMovementLocked.ts` exposes the shared repair movement-lock rule used by the player controller and UI indicator.
 - `src/hooks/handTracking/useBothFistsHold.ts` detects the reusable two-fists hold gesture.
 - `src/components/three/gameplay/RepairCaseModel.tsx` renders and animates the case model, and exposes `placeholder_*` transforms when the GLTF provides them.
 - `src/components/three/models/ExplodableModel.tsx` renders selectable models with split/exploded visualization.
 - `src/data/gameplay/repairCaseConfig.ts` stores repair case model, sound, and animation constants.
 - `src/data/gameplay/repairGameConfig.ts` stores repair flow timing constants.
-- `src/data/gameplay/repairMissions.ts` stores reusable repair mission config for `bike`, `pylone`, and `ferme`.
+- `src/data/gameplay/repairMissions.ts` stores reusable repair mission config for `ebike`, `pylon`, and `farm`.
 - `src/managers/stores/useGameStore.ts` stores mission progression state and generic mission step helpers.
 - `src/types/gameplay/repairMission.ts` contains shared repair mission ids, mission steps, and guards used by the store, data config, debug UI, and gameplay components.
 
@@ -73,7 +73,7 @@ The mission config now carries the mission-specific variations. `bike` repairs o
 
 The production repair flow currently requires:
 
-- the active `mainState` to be one of `bike`, `pylone`, or `ferme`
+- the active `mainState` to be one of `ebike`, `pylon`, or `farm`
 - `GameStageContent` mounted inside the game scene Rapier `Physics` boundary
 - model assets available under `public/models/`
 - sound assets available under `public/sounds/`

scripts/transformMap.cjs

@@ -26,6 +26,32 @@ const IDENTITY_NODE = {
   scale: [1, 1, 1],
 };
 const MAX_MESH_Y_PLACEMENT_OFFSET = 2;
+const RAW_INDEX = {
+  directionGroup: 5,
+  fermeGroup: 4798,
+  energieGroup: 4800,
+  lafabrikGroup: 4873,
+  ecoleGroup: 4895,
+  residenceZoneSources: [830, 874, 892],
+};
+const RAW_RANGES = {
+  directionPrimary: [6, 12],
+  residenceZone1: [831, 873],
+  residenceZone2: [875, 891],
+  residenceZone3: [893, 942],
+  residenceBikes: [14, 23],
+  residenceMailboxes: [25, 58],
+  energyPylones: [61, 96],
+  vegetationPrimary: [98, 829],
+  lakePipes: [944, 944],
+  fields: [946, 4594],
+  farm: [4595, 4799],
+  vegetationFarmArea: [4750, 4797],
+  energy: [4801, 4872],
+  lafabrik: [4874, 4894],
+  directionSecondary: [4896, 4897],
+  vegetationSecondary: [4898, 4997],
+};
 
 function cloneNode(node) {
   return {
@@ -69,6 +95,15 @@ function getOrCreateModelGroup(parent, modelName) {
   return group;
 }
 
+function getRequiredRawNode(rawData, index, label) {
+  const node = rawData[index];
+  if (!node) {
+    throw new Error(`Missing raw map node for ${label} at index ${index}`);
+  }
+
+  return node;
+}
+
 function createRenderableObject(objectNode, meshNode) {
   const mappedMesh = mapMeshNode(meshNode);
   const renderableNode = cloneNode(objectNode ?? meshNode);
@@ -177,28 +212,53 @@ function getNearestGroup(groups, node) {
 }
 
 function createResidenceZones(rawData, residence) {
-  const zoneSources = [rawData[830], rawData[874], rawData[892]];
+  const zoneSources = RAW_INDEX.residenceZoneSources.map((index) =>
+    getRequiredRawNode(rawData, index, `residence zone ${index}`),
+  );
   const zones = zoneSources.map((sourceNode, index) => {
     const zone = createGroup(`zone${index + 1}_residence`, sourceNode);
     residence.children.push(zone);
     return zone;
   });
 
-  addBuildingsByRange(rawData, zones[0], 831, 873);
-  addBuildingsByRange(rawData, zones[1], 875, 891);
-  addBuildingsByRange(rawData, zones[2], 893, 942);
-  addObjectsByRange(rawData, zones[0], 831, 873, RESIDENCE_MESH_NAMES);
-  addObjectsByRange(rawData, zones[1], 875, 891, RESIDENCE_MESH_NAMES);
-  addObjectsByRange(rawData, zones[2], 893, 942, RESIDENCE_MESH_NAMES);
+  addBuildingsByRange(rawData, zones[0], ...RAW_RANGES.residenceZone1);
+  addBuildingsByRange(rawData, zones[1], ...RAW_RANGES.residenceZone2);
+  addBuildingsByRange(rawData, zones[2], ...RAW_RANGES.residenceZone3);
+  addObjectsByRange(
+    rawData,
+    zones[0],
+    ...RAW_RANGES.residenceZone1,
+    RESIDENCE_MESH_NAMES,
+  );
+  addObjectsByRange(
+    rawData,
+    zones[1],
+    ...RAW_RANGES.residenceZone2,
+    RESIDENCE_MESH_NAMES,
+  );
+  addObjectsByRange(
+    rawData,
+    zones[2],
+    ...RAW_RANGES.residenceZone3,
+    RESIDENCE_MESH_NAMES,
+  );
 
-  for (let i = 14; i <= 23; i++) {
+  for (
+    let i = RAW_RANGES.residenceBikes[0];
+    i <= RAW_RANGES.residenceBikes[1];
+    i++
+  ) {
     const node = rawData[i];
     if (node?.type === "Mesh" && node.name === "parcebike") {
       addRenderable(getNearestGroup(zones, node), null, node);
     }
   }
 
-  for (let i = 25; i <= 58; i++) {
+  for (
+    let i = RAW_RANGES.residenceMailboxes[0];
+    i <= RAW_RANGES.residenceMailboxes[1];
+    i++
+  ) {
     const node = rawData[i];
     if (node?.type === "Mesh" && node.name === "boitesauxlettres") {
       addRenderable(getNearestGroup(zones, node), null, node);
@@ -266,12 +326,27 @@ function transformMap() {
   const vegetation = createGroup("vegetation");
   const agriculture = createGroup("agriculture");
   const champs = createGroup("champs");
-  const ferme = createGroup("ferme", rawData[4798]);
+  const ferme = createGroup(
+    "ferme",
+    getRequiredRawNode(rawData, RAW_INDEX.fermeGroup, "ferme group"),
+  );
   const residence = createGroup("residence");
-  const energie = createGroup("energie", rawData[4800]);
-  const direction = createGroup("direction", rawData[5]);
-  const lafabrik = createGroup("lafabrik", rawData[4873]);
-  const ecole = createGroup("ecole", rawData[4895]);
+  const energie = createGroup(
+    "energie",
+    getRequiredRawNode(rawData, RAW_INDEX.energieGroup, "energie group"),
+  );
+  const direction = createGroup(
+    "direction",
+    getRequiredRawNode(rawData, RAW_INDEX.directionGroup, "direction group"),
+  );
+  const lafabrik = createGroup(
+    "lafabrik",
+    getRequiredRawNode(rawData, RAW_INDEX.lafabrikGroup, "lafabrik group"),
+  );
+  const ecole = createGroup(
+    "ecole",
+    getRequiredRawNode(rawData, RAW_INDEX.ecoleGroup, "ecole group"),
+  );
   delete ecole.role;
   const unclassified = createGroup("unclassified");
 
@@ -288,20 +363,60 @@ function transformMap() {
   );
   agriculture.children.push(champs, ferme);
 
-  addObjectsByRange(rawData, direction, 6, 12, DIRECTION_MESH_NAMES);
+  addObjectsByRange(
+    rawData,
+    direction,
+    ...RAW_RANGES.directionPrimary,
+    DIRECTION_MESH_NAMES,
+  );
   addStandaloneObject(rawData, residence, "ebike");
   createResidenceZones(rawData, residence);
-  addObjectsByRange(rawData, energie, 61, 96, new Set(["pyloneelectrique"]));
-  addObjectsByRange(rawData, vegetation, 98, 829, VEGETATION_MESH_NAMES);
-  addObjectsByRange(rawData, agriculture, 944, 944, new Set(["tuyauxlac"]));
-  addObjectsByRange(rawData, champs, 946, 4594, CHAMP_MESH_NAMES);
-  addObjectsByRange(rawData, ferme, 4595, 4799, FERME_MESH_NAMES);
-  addObjectsByRange(rawData, vegetation, 4750, 4797, VEGETATION_MESH_NAMES);
-  addObjectsByRange(rawData, energie, 4801, 4872, ENERGIE_MESH_NAMES);
-  addBuildingsByRange(rawData, lafabrik, 4874, 4894);
-  addObjectsByRange(rawData, lafabrik, 4874, 4894, LAFABRIK_MESH_NAMES);
-  addObjectsByRange(rawData, direction, 4896, 4897, DIRECTION_MESH_NAMES);
-  addObjectsByRange(rawData, vegetation, 4898, 4997, VEGETATION_MESH_NAMES);
+  addObjectsByRange(
+    rawData,
+    energie,
+    ...RAW_RANGES.energyPylones,
+    new Set(["pyloneelectrique"]),
+  );
+  addObjectsByRange(
+    rawData,
+    vegetation,
+    ...RAW_RANGES.vegetationPrimary,
+    VEGETATION_MESH_NAMES,
+  );
+  addObjectsByRange(
+    rawData,
+    agriculture,
+    ...RAW_RANGES.lakePipes,
+    new Set(["tuyauxlac"]),
+  );
+  addObjectsByRange(rawData, champs, ...RAW_RANGES.fields, CHAMP_MESH_NAMES);
+  addObjectsByRange(rawData, ferme, ...RAW_RANGES.farm, FERME_MESH_NAMES);
+  addObjectsByRange(
+    rawData,
+    vegetation,
+    ...RAW_RANGES.vegetationFarmArea,
+    VEGETATION_MESH_NAMES,
+  );
+  addObjectsByRange(rawData, energie, ...RAW_RANGES.energy, ENERGIE_MESH_NAMES);
+  addBuildingsByRange(rawData, lafabrik, ...RAW_RANGES.lafabrik);
+  addObjectsByRange(
+    rawData,
+    lafabrik,
+    ...RAW_RANGES.lafabrik,
+    LAFABRIK_MESH_NAMES,
+  );
+  addObjectsByRange(
+    rawData,
+    direction,
+    ...RAW_RANGES.directionSecondary,
+    DIRECTION_MESH_NAMES,
+  );
+  addObjectsByRange(
+    rawData,
+    vegetation,
+    ...RAW_RANGES.vegetationSecondary,
+    VEGETATION_MESH_NAMES,
+  );
 
   for (let i = 0; i < rawData.length; i++) {
     const node = rawData[i];

src/components/docs/DocsDocument.tsx

@@ -6,14 +6,14 @@ interface DocsDocumentProps {
   title: string;
   meta: string;
   content: string;
-  frContent: string;
+  frContent?: string;
 }
 
 export function DocsDocument({
   title,
   meta,
   content,
-  frContent,
+  frContent = content,
 }: DocsDocumentProps): React.JSX.Element {
   const { language, toggleLanguage } = useDocsLanguage();
   const hasAlternateContent = frContent !== content;

src/components/editor/EditorControls.tsx

@@ -41,6 +41,7 @@ interface EditorControlsProps {
   onClearSelection: () => void;
   snapToTerrain: boolean;
   onSnapToTerrainToggle: () => void;
+  onSnapAllToTerrain: () => void;
   newNodeName: string;
   onNewNodeNameChange: (value: string) => void;
   onAddNode: () => void;
@@ -70,7 +71,7 @@ const EDITOR_SHORTCUTS = [
   ["Shift + Right click", "Toggle multi-selection"],
   ["T / R / S", "Transform mode"],
   ["Ctrl Z / Y", "Undo / redo"],
-  ["Esc", "Deselect"],
+  ["Esc / X button", "Clear selection"],
   ["WASD", "Move when locked"],
 ] as const;
 
@@ -117,6 +118,7 @@ export function EditorControls({
   onClearSelection,
   snapToTerrain,
   onSnapToTerrainToggle,
+  onSnapAllToTerrain,
   newNodeName,
   onNewNodeNameChange,
   onAddNode,
@@ -228,6 +230,15 @@ export function EditorControls({
               />
               <span>Snap terrain on move</span>
             </label>
+
+            <button
+              type="button"
+              className="editor-history-button"
+              onClick={onSnapAllToTerrain}
+            >
+              <ScanSearch size={15} aria-hidden="true" />
+              Snap all to terrain
+            </button>
           </section>
 
           <section

src/components/editor/EditorSrtPanel.tsx

@@ -496,10 +496,16 @@ export function EditorSrtPanel(): React.JSX.Element {
         setContent(await response.text());
         setStatus(`Charge depuis ${srtPath}`);
       })
-      .catch(() => {
+      .catch((error: unknown) => {
         if (!mounted) return;
         setContent(srtTemplate);
-        setStatus("Erreur de chargement, template local cree");
+        setStatus(
+          `Erreur de chargement, template local cree: ${error instanceof Error ? error.message : "Erreur inconnue"}`,
+        );
+        logger.warn("EditorSrt", "Falling back to local SRT template", {
+          srtPath,
+          error: error instanceof Error ? error : String(error),
+        });
       });
 
     return () => {

src/components/editor/scene/EditorMap.tsx

@@ -12,6 +12,8 @@ import {
   isEditorVisibleMapNode,
   getTerrainMapNode,
 } from "@/utils/map/mapRuntimeClassification";
+import { getMapModelScaleMultiplier } from "@/data/world/mapInstancingConfig";
+import { getVegetationModelScaleMultiplier } from "@/data/world/vegetationConfig";
 
 interface EditorMapProps {
   sceneData: SceneData;
@@ -28,6 +30,8 @@ interface EditorMapProps {
   onTransformStart: () => void;
   onTransformEnd: () => void;
   onNodeTransform: (nodeIndex: number, transform: MapNode) => void;
+  snapAllToTerrainRequest: number;
+  onSnapAllToTerrain: (mapNodes: MapNode[]) => void;
 }
 
 type EditorNodeObjectRef = React.RefObject<Map<number, THREE.Object3D>>;
@@ -64,6 +68,32 @@ const TEMP_POSITION = new THREE.Vector3();
 const TEMP_QUATERNION = new THREE.Quaternion();
 const TEMP_SCALE = new THREE.Vector3();
 
+function isOriginPosition(position: MapNode["position"]): boolean {
+  return position.every((value) => Math.abs(value) < 0.0001);
+}
+
+function isSnapAllCandidate(node: MapNode): boolean {
+  return (
+    isEditorVisibleMapNode(node) &&
+    node.name !== "terrain" &&
+    !isOriginPosition(node.position)
+  );
+}
+
+function shouldRenderEditorNode(
+  node: MapNode,
+  selectedNodeName: string | null,
+): boolean {
+  if (!isEditorVisibleMapNode(node)) return false;
+  return selectedNodeName === null || node.name === selectedNodeName;
+}
+
+function getEditorModelVisualScaleMultiplier(name: string): number {
+  return (
+    getMapModelScaleMultiplier(name) * getVegetationModelScaleMultiplier(name)
+  );
+}
+
 function applyNodeTransform(object: THREE.Object3D, node: MapNode): void {
   object.position.set(...node.position);
   object.rotation.set(...node.rotation);
@@ -177,14 +207,21 @@ export function EditorMap({
   onTransformStart,
   onTransformEnd,
   onNodeTransform,
+  snapAllToTerrainRequest,
+  onSnapAllToTerrain,
 }: EditorMapProps): React.JSX.Element {
   const objectsMapRef = useRef<Map<number, THREE.Object3D>>(new Map());
   const transformGroupRef = useRef<THREE.Group>(null);
   const transformSnapshotRef = useRef<TransformSnapshot | null>(null);
   const terrainHeight = useTerrainHeightSampler();
+  const lastSnapAllToTerrainRequestRef = useRef(0);
 
   const selectedIndexSet = new Set(selectedNodeIndexes);
   const isMultiSelection = selectedNodeIndexes.length > 1;
+  const selectedNodeName =
+    selectedNodeIndex !== null
+      ? (sceneData.mapNodes[selectedNodeIndex]?.name ?? null)
+      : null;
 
   const getTransformObject = useCallback(() => {
     if (isMultiSelection) {
@@ -333,6 +370,37 @@ export function EditorMap({
     prepareTransformGroup();
   }, [prepareTransformGroup]);
 
+  useEffect(() => {
+    if (
+      snapAllToTerrainRequest === 0 ||
+      snapAllToTerrainRequest === lastSnapAllToTerrainRequestRef.current
+    ) {
+      return;
+    }
+
+    lastSnapAllToTerrainRequestRef.current = snapAllToTerrainRequest;
+
+    const snappedNodes = sceneData.mapNodes.map((node) => {
+      if (!isSnapAllCandidate(node)) return node;
+
+      const [x, y, z] = node.position;
+      const terrainY = terrainHeight.getHeight(x, z);
+      if (terrainY === null || Math.abs(terrainY - y) < 0.0001) return node;
+
+      return {
+        ...node,
+        position: [x, terrainY, z] satisfies [number, number, number],
+      };
+    });
+
+    onSnapAllToTerrain(snappedNodes);
+  }, [
+    onSnapAllToTerrain,
+    sceneData.mapNodes,
+    snapAllToTerrainRequest,
+    terrainHeight,
+  ]);
+
   // TransformControls needs the current Three object; editor refs are managed outside React rendering.
   // eslint-disable-next-line react-hooks/refs
   const selectedObject = getTransformObject();
@@ -370,7 +438,7 @@ export function EditorMap({
           />
         ) : null}
         {sceneData.mapNodes.map((node, index) => {
-          if (!isEditorVisibleMapNode(node)) {
+          if (!shouldRenderEditorNode(node, selectedNodeName)) {
             return null;
           }
 
@@ -451,6 +519,7 @@ function EditorModelNode({
     scale: node.scale,
   });
   const sceneInstance = useClonedObject(scene);
+  const visualScaleMultiplier = getEditorModelVisualScaleMultiplier(node.name);
   const pointerHandlers = createEditorNodePointerHandlers(
     index,
     onSelectNode,
@@ -512,14 +581,15 @@ function EditorModelNode({
   }, []);
 
   return (
-    <primitive
+    <group
       ref={groupRef}
-      object={sceneInstance}
       position={node.position}
       rotation={node.rotation}
       scale={node.scale}
       {...pointerHandlers}
-    />
+    >
+      <primitive object={sceneInstance} scale={visualScaleMultiplier} />
+    </group>
   );
 }
 

src/components/editor/scene/EditorScene.tsx

@@ -6,6 +6,7 @@ import * as THREE from "three";
 import type { OrbitControls as OrbitControlsImpl } from "three-stdlib";
 import { EditorMap } from "@/components/editor/scene/EditorMap";
 import { FlyController } from "@/controls/editor/FlyController";
+import { PersonnageSystem } from "@/world/personnages/PersonnageSystem";
 import type { CinematicDefinition } from "@/types/cinematics/cinematics";
 import type { MapNode, TransformMode, SceneData } from "@/types/editor/editor";
 
@@ -33,6 +34,8 @@ interface EditorSceneProps {
   onTransformStart: () => void;
   onTransformEnd: () => void;
   onNodeTransform: (nodeIndex: number, transform: MapNode) => void;
+  snapAllToTerrainRequest: number;
+  onSnapAllToTerrain: (mapNodes: MapNode[]) => void;
   onUndo: () => void;
   onRedo: () => void;
   resetCameraRequest: number;
@@ -58,6 +61,8 @@ export function EditorScene({
   onTransformStart,
   onTransformEnd,
   onNodeTransform,
+  snapAllToTerrainRequest,
+  onSnapAllToTerrain,
   onUndo,
   onRedo,
   resetCameraRequest,
@@ -224,8 +229,12 @@ export function EditorScene({
         onTransformStart={onTransformStart}
         onTransformEnd={onTransformEnd}
         onNodeTransform={onNodeTransform}
+        snapAllToTerrainRequest={snapAllToTerrainRequest}
+        onSnapAllToTerrain={onSnapAllToTerrain}
       />
 
+      <PersonnageSystem />
+
       <ambientLight intensity={0.6} />
       <directionalLight position={[10, 20, 10]} intensity={1.5} castShadow />
       <directionalLight position={[-10, 10, -10]} intensity={0.5} />

src/components/game/GameFlow.tsx

@@ -8,6 +8,7 @@ export function GameFlow(): null {
   const setStep = useGameStore((state) => state.setIntroStep);
   const setActivityCity = useGameStore((state) => state.setActivityCity);
   const setCanMove = useGameStore((state) => state.setCanMove);
+  const completeIntro = useGameStore((state) => state.completeIntro);
   const hasInitialized = useRef(false);
 
   useEffect(() => {
@@ -55,10 +56,17 @@ export function GameFlow(): null {
 
     if (step === "manipulation") {
       setCanMove(false);
+      const timeoutId = window.setTimeout(() => {
+        completeIntro();
+      }, 1000);
+
+      return () => {
+        window.clearTimeout(timeoutId);
+      };
     }
 
     return undefined;
-  }, [step, setStep, setActivityCity, setCanMove]);
+  }, [completeIntro, step, setStep, setActivityCity, setCanMove]);
 
   return null;
 }

src/components/three/interaction/InteractableObject.tsx

@@ -41,8 +41,27 @@ type InteractableObjectProps =
 const _cameraPos = new THREE.Vector3();
 const _cameraDir = new THREE.Vector3();
 const _objectPos = new THREE.Vector3();
+const _objectBounds = new THREE.Box3();
 const _raycaster = new THREE.Raycaster();
 
+function getInteractableWorldPosition(
+  group: THREE.Group,
+  debugSphere: THREE.Mesh | null,
+): THREE.Vector3 {
+  _objectBounds.makeEmpty();
+
+  for (const child of group.children) {
+    if (child === debugSphere) continue;
+    _objectBounds.expandByObject(child);
+  }
+
+  if (!_objectBounds.isEmpty()) {
+    return _objectBounds.getCenter(_objectPos);
+  }
+
+  return group.getWorldPosition(_objectPos);
+}
+
 function createInteractableHandle(
   props: InteractableObjectProps,
 ): InteractableHandle {
@@ -158,7 +177,7 @@ export function InteractableObject(
       const t = bodyRef.current.translation();
       _objectPos.set(t.x, t.y, t.z);
     } else if (group) {
-      group.getWorldPosition(_objectPos);
+      getInteractableWorldPosition(group, debugSphereRef.current);
     } else {
       _objectPos.set(...position);
     }

src/components/three/models/AnimatedModel.tsx

@@ -68,32 +68,6 @@ export function AnimatedModel({
     }
   }, [mixer, onAnimationEnd]);
 
-  const play = useCallback(
-    (name: string, fade = fadeDuration) => {
-      const action = actions[name];
-      if (action) {
-        Object.values(actions).forEach((a) => {
-          if (a && a !== action) a.fadeOut(fade);
-        });
-        action.reset().fadeIn(fade).play();
-        setCurrentAnim(name);
-      }
-    },
-    [actions, fadeDuration],
-  );
-
-  const stop = useCallback(
-    (fade = fadeDuration) => {
-      Object.values(actions).forEach((a) => a?.fadeOut(fade));
-      const defaultAction = actions[defaultAnimation];
-      if (defaultAction) {
-        defaultAction.reset().fadeIn(fade).play();
-        setCurrentAnim(defaultAnimation);
-      }
-    },
-    [actions, defaultAnimation, fadeDuration],
-  );
-
   const fadeTo = useCallback(
     (name: string, fade = fadeDuration) => {
       const action = actions[name];
@@ -107,6 +81,19 @@ export function AnimatedModel({
     },
     [actions, fadeDuration],
   );
+  const play = fadeTo;
+
+  const stop = useCallback(
+    (fade = fadeDuration) => {
+      Object.values(actions).forEach((a) => a?.fadeOut(fade));
+      const defaultAction = actions[defaultAnimation];
+      if (defaultAction) {
+        defaultAction.reset().fadeIn(fade).play();
+        setCurrentAnim(defaultAnimation);
+      }
+    },
+    [actions, defaultAnimation, fadeDuration],
+  );
 
   const setSpeed = useCallback(
     (newSpeed: number) => {
@@ -140,10 +127,21 @@ export function AnimatedModel({
     }
 
     if (defaultAction) {
-      defaultAction.play();
+      Object.values(actions).forEach((action) => {
+        if (action && action !== defaultAction) action.fadeOut(fadeDuration);
+      });
+      defaultAction.reset().fadeIn(fadeDuration).play();
       onLoaded?.();
     }
-  }, [actions, defaultAnimation, modelPath, names, autoPlay, onLoaded]);
+  }, [
+    actions,
+    defaultAnimation,
+    fadeDuration,
+    modelPath,
+    names,
+    autoPlay,
+    onLoaded,
+  ]);
 
   const contextValue: AnimatedModelContextValue = {
     play,

src/components/three/models/SimpleModel.tsx

@@ -2,7 +2,6 @@ import { useEffect, useMemo } from "react";
 import * as THREE from "three";
 import { useLoggedGLTF } from "@/hooks/three/useLoggedGLTF";
 import type { ModelTransformProps, Vector3Tuple } from "@/types/three/three";
-import { disposeObject3D } from "@/utils/three/dispose";
 
 function applyShadowSettings(
   object: THREE.Object3D,
@@ -48,12 +47,6 @@ export function SimpleModel({
     applyShadowSettings(model, castShadow, receiveShadow);
   }, [castShadow, model, receiveShadow]);
 
-  useEffect(() => {
-    return () => {
-      disposeObject3D(model);
-    };
-  }, [model]);
-
   const parsedScale =
     typeof scale === "number" ? ([scale, scale, scale] as Vector3Tuple) : scale;
 

src/components/three/world/EcoleModel.tsx

@@ -1,17 +1,12 @@
 import { useGLTF } from "@react-three/drei";
-import { MergedStaticMapModel } from "@/components/three/world/MergedStaticMapModel";
-import type { Vector3Tuple } from "@/types/three/three";
+import {
+  MergedStaticMapModel,
+  type MergedStaticMapModelProps,
+} from "@/components/three/world/MergedStaticMapModel";
 
 const ECOLE_MODEL_PATH = "/models/ecole/model.gltf";
 
-interface EcoleModelProps {
-  position: Vector3Tuple;
-  rotation: Vector3Tuple;
-  scale: Vector3Tuple;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  onLoaded?: () => void;
-}
+type EcoleModelProps = Omit<MergedStaticMapModelProps, "modelPath">;
 
 export function EcoleModel(props: EcoleModelProps): React.JSX.Element {
   return <MergedStaticMapModel modelPath={ECOLE_MODEL_PATH} {...props} />;

src/components/three/world/FermeVerticaleModel.tsx

@@ -1,17 +1,12 @@
 import { useGLTF } from "@react-three/drei";
-import { MergedStaticMapModel } from "@/components/three/world/MergedStaticMapModel";
-import type { Vector3Tuple } from "@/types/three/three";
+import {
+  MergedStaticMapModel,
+  type MergedStaticMapModelProps,
+} from "@/components/three/world/MergedStaticMapModel";
 
 const FERME_VERTICALE_MODEL_PATH = "/models/fermeverticale/model.gltf";
 
-interface FermeVerticaleModelProps {
-  position: Vector3Tuple;
-  rotation: Vector3Tuple;
-  scale: Vector3Tuple;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  onLoaded?: () => void;
-}
+type FermeVerticaleModelProps = Omit<MergedStaticMapModelProps, "modelPath">;
 
 export function FermeVerticaleModel(
   props: FermeVerticaleModelProps,

src/components/three/world/GenerateurModel.tsx

@@ -1,17 +1,12 @@
 import { useGLTF } from "@react-three/drei";
-import { MergedStaticMapModel } from "@/components/three/world/MergedStaticMapModel";
-import type { Vector3Tuple } from "@/types/three/three";
+import {
+  MergedStaticMapModel,
+  type MergedStaticMapModelProps,
+} from "@/components/three/world/MergedStaticMapModel";
 
 const GENERATEUR_MODEL_PATH = "/models/generateur/model.gltf";
 
-interface GenerateurModelProps {
-  position: Vector3Tuple;
-  rotation: Vector3Tuple;
-  scale: Vector3Tuple;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  onLoaded?: () => void;
-}
+type GenerateurModelProps = Omit<MergedStaticMapModelProps, "modelPath">;
 
 export function GenerateurModel(
   props: GenerateurModelProps,

src/components/three/world/LafabrikModel.tsx

@@ -1,17 +1,12 @@
 import { useGLTF } from "@react-three/drei";
-import { MergedStaticMapModel } from "@/components/three/world/MergedStaticMapModel";
-import type { Vector3Tuple } from "@/types/three/three";
+import {
+  MergedStaticMapModel,
+  type MergedStaticMapModelProps,
+} from "@/components/three/world/MergedStaticMapModel";
 
 const LAFABRIK_MODEL_PATH = "/models/lafabrik/model.gltf";
 
-interface LafabrikModelProps {
-  position: Vector3Tuple;
-  rotation: Vector3Tuple;
-  scale: Vector3Tuple;
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  onLoaded?: () => void;
-}
+type LafabrikModelProps = Omit<MergedStaticMapModelProps, "modelPath">;
 
 export function LafabrikModel(props: LafabrikModelProps): React.JSX.Element {
   return <MergedStaticMapModel modelPath={LAFABRIK_MODEL_PATH} {...props} />;

src/components/three/world/MergedStaticMapModel.tsx

@@ -6,7 +6,7 @@ import { mergeGeometries } from "three/addons/utils/BufferGeometryUtils.js";
 import type { Vector3Tuple } from "@/types/three/three";
 import { optimizeGLTFSceneTextures } from "@/utils/three/optimizeGLTFScene";
 
-interface MergedStaticMapModelProps {
+export interface MergedStaticMapModelProps {
   modelPath: string;
   position: Vector3Tuple;
   rotation: Vector3Tuple;

src/components/three/world/SkyModel.tsx

@@ -7,8 +7,6 @@ import { useLoggedGLTF } from "@/hooks/three/useLoggedGLTF";
 interface SkyModelProps {
   modelPath: string;
   fallbackColor?: string | undefined;
-  fallbackModelPath?: string | undefined;
-  fallbackScale?: number | undefined;
   scale?: number | undefined;
 }
 
@@ -29,7 +27,6 @@ interface SkyModelErrorBoundaryState {
 const SKY_MODEL_SCALE = 1;
 const SKY_MODEL_RENDER_ORDER = -1000;
 const SKYBOX_MODEL_PATH = "/models/skybox/model.gltf";
-const LEGACY_SKY_MODEL_PATH = "/models/sky/model.glb";
 
 class SkyModelErrorBoundary extends Component<
   SkyModelErrorBoundaryProps,
@@ -55,21 +52,12 @@ class SkyModelErrorBoundary extends Component<
 
 export function SkyModel({
   fallbackColor,
-  fallbackModelPath,
-  fallbackScale = SKY_MODEL_SCALE,
   modelPath,
   scale = SKY_MODEL_SCALE,
 }: SkyModelProps): React.JSX.Element {
-  const colorFallback = fallbackColor ? (
+  const fallback = fallbackColor ? (
     <color attach="background" args={[fallbackColor]} />
   ) : null;
-  const fallback = fallbackModelPath ? (
-    <SkyModelErrorBoundary key={fallbackModelPath} fallback={colorFallback}>
-      <SkyModelContent modelPath={fallbackModelPath} scale={fallbackScale} />
-    </SkyModelErrorBoundary>
-  ) : (
-    colorFallback
-  );
 
   return (
     <SkyModelErrorBoundary key={modelPath} fallback={fallback}>
@@ -154,4 +142,3 @@ function disposeSkyModelMaterials(model: THREE.Object3D): void {
 }
 
 useGLTF.preload(SKYBOX_MODEL_PATH);
-useGLTF.preload(LEGACY_SKY_MODEL_PATH);

src/components/ui/debug/GameStateDebugPanel.tsx

@@ -1,12 +1,15 @@
 import { RotateCcw, StepBack, StepForward } from "lucide-react";
-import { useGameStore } from "@/managers/stores/useGameStore";
-import { isMissionStep, MISSION_STEPS } from "@/types/gameplay/repairMission";
 import {
   GAME_STEPS,
   isGameStep,
   MAIN_GAME_STATES,
-  type MainGameState,
-} from "@/types/game";
+} from "@/data/game/gameStateConfig";
+import {
+  isMissionStep,
+  MISSION_STEPS,
+} from "@/data/gameplay/repairMissionState";
+import { useGameStore } from "@/managers/stores/useGameStore";
+import type { MainGameState } from "@/types/game";
 
 function toPascalCase(value: string): string {
   return value
@@ -19,18 +22,18 @@ function toPascalCase(value: string): string {
 export function GameStateDebugPanel(): React.JSX.Element {
   const mainState = useGameStore((state) => state.mainState);
   const ebikeStep = useGameStore((state) => state.ebike.currentStep);
-  const pyloneStep = useGameStore((state) => state.pylone.currentStep);
-  const fermeStep = useGameStore((state) => state.ferme.currentStep);
+  const pylonStep = useGameStore((state) => state.pylon.currentStep);
+  const farmStep = useGameStore((state) => state.farm.currentStep);
   const detail = useGameStore((state) => {
     switch (state.mainState) {
       case "intro":
         return state.intro.currentStep;
       case "ebike":
         return state.ebike.currentStep;
-      case "pylone":
-        return state.pylone.currentStep;
-      case "ferme":
-        return state.ferme.currentStep;
+      case "pylon":
+        return state.pylon.currentStep;
+      case "farm":
+        return state.farm.currentStep;
       case "outro":
         return state.outro.hasStarted ? "started" : "waiting";
     }
@@ -38,8 +41,8 @@ export function GameStateDebugPanel(): React.JSX.Element {
   const setMainState = useGameStore((state) => state.setMainState);
   const setIntroStep = useGameStore((state) => state.setIntroStep);
   const setEbikeState = useGameStore((state) => state.setEbikeState);
-  const setPyloneState = useGameStore((state) => state.setPyloneState);
-  const setFermeState = useGameStore((state) => state.setFermeState);
+  const setPylonState = useGameStore((state) => state.setPylonState);
+  const setFarmState = useGameStore((state) => state.setFarmState);
   const setOutroState = useGameStore((state) => state.setOutroState);
   const advanceGameState = useGameStore((state) => state.advanceGameState);
   const rewindGameState = useGameStore((state) => state.rewindGameState);
@@ -72,13 +75,13 @@ export function GameStateDebugPanel(): React.JSX.Element {
       return;
     }
 
-    if (mainState === "pylone") {
-      setPyloneState({ currentStep: nextSubState });
+    if (mainState === "pylon") {
+      setPylonState({ currentStep: nextSubState });
       return;
     }
 
-    if (mainState === "ferme") {
-      setFermeState({ currentStep: nextSubState });
+    if (mainState === "farm") {
+      setFarmState({ currentStep: nextSubState });
       return;
     }
   }
@@ -86,18 +89,34 @@ export function GameStateDebugPanel(): React.JSX.Element {
   function setDebugMainState(nextMainState: MainGameState): void {
     setMainState(nextMainState);
 
+    if (
+      nextMainState === "pylon" ||
+      nextMainState === "farm" ||
+      nextMainState === "outro"
+    ) {
+      setEbikeState({ currentStep: "done", isRepaired: true });
+    }
+
+    if (nextMainState === "farm" || nextMainState === "outro") {
+      setPylonState({ currentStep: "done", isPowered: true });
+    }
+
+    if (nextMainState === "outro") {
+      setFarmState({ currentStep: "done", irrigationFixed: true });
+    }
+
     if (nextMainState === "ebike" && ebikeStep === "locked") {
       setEbikeState({ currentStep: "waiting" });
       return;
     }
 
-    if (nextMainState === "pylone" && pyloneStep === "locked") {
-      setPyloneState({ currentStep: "waiting" });
+    if (nextMainState === "pylon" && pylonStep === "locked") {
+      setPylonState({ currentStep: "waiting" });
       return;
     }
 
-    if (nextMainState === "ferme" && fermeStep === "locked") {
-      setFermeState({ currentStep: "waiting" });
+    if (nextMainState === "farm" && farmStep === "locked") {
+      setFarmState({ currentStep: "waiting" });
     }
   }
 

src/components/zone/ZoneDetection.tsx

@@ -4,7 +4,7 @@ import * as THREE from "three";
 import { ZONES } from "@/data/zones";
 import { useGameStore } from "@/managers/stores/useGameStore";
 import { Debug } from "@/utils/debug/Debug";
-import { GAME_STEPS } from "@/types/game";
+import { GAME_STEPS } from "@/data/game/gameStateConfig";
 
 const _playerPos = new THREE.Vector3();
 const _zonePos = new THREE.Vector3();

src/data/audioConfig.ts

@@ -5,3 +5,11 @@ export const AUDIO_PATHS = {
   searching: "/sounds/effect/fa.mp3",
   helped: "/sounds/effect/fa.mp3",
 } as const;
+
+export type AudioCategory = "music" | "sfx" | "dialogue";
+
+export const DEFAULT_CATEGORY_VOLUMES: Record<AudioCategory, number> = {
+  music: 1,
+  sfx: 1,
+  dialogue: 1,
+};

src/data/debug/testSceneConfig.ts

@@ -31,19 +31,19 @@ export const TEST_SCENE_REPAIR_ZONES = [
     position: [-12, 0, -12],
   },
   {
-    mission: "pylone",
-    label: "Pylone",
+    mission: "pylon",
+    label: "Pylon",
     color: "#facc15",
     position: [0, 0, -12],
   },
   {
-    mission: "ferme",
+    mission: "farm",
     label: "Farm",
     color: "#86efac",
     position: [12, 0, -12],
   },
 ] as const satisfies readonly {
-  mission: "ebike" | "pylone" | "ferme";
+  mission: "ebike" | "pylon" | "farm";
   label: string;
   color: string;
   position: Vector3Tuple;

src/data/docs/docsSections.ts

@@ -38,53 +38,59 @@ export const docGroups: DocGroup[] = [
         subtitle: "Gameplay implementation",
         meta: "04",
       },
+      {
+        path: "/docs/mission-flow",
+        title: "Mission Flow",
+        subtitle: "Intro and mission progression",
+        meta: "05",
+      },
       {
         path: "/docs/interaction",
         title: "Interaction System",
         subtitle: "Trigger, grab, hand input",
-        meta: "05",
+        meta: "06",
       },
       {
         path: "/docs/target-architecture",
         title: "Target Architecture",
         subtitle: "Next direction",
-        meta: "06",
+        meta: "07",
       },
       {
         path: "/docs/technical-editor",
         title: "Editor Technical Notes",
         subtitle: "Implementation details",
-        meta: "07",
+        meta: "08",
       },
       {
         path: "/docs/audio",
         title: "Audio Technical Notes",
         subtitle: "Music, dialogue, SRT, and SFX",
-        meta: "08",
+        meta: "09",
       },
       {
         path: "/docs/hand-tracking",
         title: "Hand Tracking Technical Notes",
         subtitle: "Webcam interaction pipeline",
-        meta: "09",
+        meta: "10",
       },
       {
         path: "/docs/zustand",
         title: "Zustand Stores",
         subtitle: "Game, settings, subtitles",
-        meta: "10",
+        meta: "11",
       },
       {
         path: "/docs/three-debugging",
         title: "Three Debugging",
         subtitle: "Step into Three.js internals",
-        meta: "11",
+        meta: "12",
       },
       {
         path: "/docs/map-performance",
         title: "Map Performance",
         subtitle: "Draw calls, triangles, and streaming",
-        meta: "12",
+        meta: "13",
       },
     ],
   },
@@ -95,25 +101,25 @@ export const docGroups: DocGroup[] = [
         path: "/docs/features",
         title: "Features",
         subtitle: "Implemented scope",
-        meta: "13",
+        meta: "14",
       },
       {
         path: "/docs/main-feature",
         title: "Main Feature",
         subtitle: "Repair-game prototype",
-        meta: "14",
+        meta: "15",
       },
       {
         path: "/docs/editor",
         title: "Editor User Guide",
         subtitle: "Editing workflow",
-        meta: "15",
+        meta: "16",
       },
       {
         path: "/docs/animation",
         title: "Animation & 3D Model System",
         subtitle: "Components and usage",
-        meta: "16",
+        meta: "17",
       },
     ],
   },
@@ -124,7 +130,7 @@ export const docGroups: DocGroup[] = [
         path: "/docs/code-review",
         title: "Code Review Prep",
         subtitle: "Presentation support",
-        meta: "17",
+        meta: "18",
       },
     ],
   },

src/data/game/gameStateConfig.ts

@@ -0,0 +1,33 @@
+import type { GameStep, MainGameState } from "@/types/game";
+
+export const GAME_STEPS: readonly GameStep[] = [
+  "intro",
+  "start-intro",
+  "naming",
+  "bienvenue",
+  "star-move",
+  "mission2",
+  "searching",
+  "helped",
+  "manipulation",
+  "outOfFabrik",
+];
+
+export const MAIN_GAME_STATES: readonly MainGameState[] = [
+  "intro",
+  "ebike",
+  "pylon",
+  "farm",
+  "outro",
+] as const;
+
+const GAME_STEP_VALUES: ReadonlySet<string> = new Set(GAME_STEPS);
+const MAIN_GAME_STATE_VALUES: ReadonlySet<string> = new Set(MAIN_GAME_STATES);
+
+export function isGameStep(value: unknown): value is GameStep {
+  return typeof value === "string" && GAME_STEP_VALUES.has(value);
+}
+
+export function isMainGameState(value: unknown): value is MainGameState {
+  return typeof value === "string" && MAIN_GAME_STATE_VALUES.has(value);
+}

src/data/gameplay/repairMissionAnchors.ts

@@ -1,5 +1,8 @@
 import type { Vector3Tuple } from "@/types/three/three";
-import type { RepairMissionId } from "@/types/gameplay/repairMission";
+import type {
+  RepairMissionId,
+  RepairMissionTriggerConfig,
+} from "@/types/gameplay/repairMission";
 
 export const EBIKE_REPAIR_POSITION = [
   42.2399, 4.5484, 34.6468,
@@ -7,15 +10,24 @@ export const EBIKE_REPAIR_POSITION = [
 
 const REPAIR_MISSION_POSITIONS = {
   ebike: EBIKE_REPAIR_POSITION,
-  pylone: [64, 0, -66],
-  ferme: [-24, 0, 42],
+  pylon: [64, 0, -66],
+  farm: [-24, 0, 42],
 } as const satisfies Record<RepairMissionId, Vector3Tuple>;
 
-export const REPAIR_MISSION_POSITION_ENTRIES = [
-  { mission: "ebike", position: REPAIR_MISSION_POSITIONS.ebike },
-  { mission: "pylone", position: REPAIR_MISSION_POSITIONS.pylone },
-  { mission: "ferme", position: REPAIR_MISSION_POSITIONS.ferme },
-] as const satisfies readonly {
+export const REPAIR_MISSION_TRIGGERS = [
+  {
+    mission: "ebike",
+    label: "Réparer l'e-bike",
+    radius: 4,
+  },
+] as const satisfies readonly RepairMissionTriggerConfig[];
+
+export const REPAIR_MISSION_POSITION_ENTRIES = Object.entries(
+  REPAIR_MISSION_POSITIONS,
+).map(([mission, position]) => ({
+  mission: mission as RepairMissionId,
+  position,
+})) satisfies readonly {
   mission: RepairMissionId;
   position: Vector3Tuple;
 }[];

src/data/gameplay/repairMissionState.ts

@@ -0,0 +1,69 @@
+import type {
+  MissionStep,
+  RepairMissionId,
+} from "@/types/gameplay/repairMission";
+
+const REPAIR_MISSION_IDS = ["ebike", "pylon", "farm"] as const;
+const REPAIR_MISSION_ID_VALUES: ReadonlySet<string> = new Set(
+  REPAIR_MISSION_IDS,
+);
+
+export const MISSION_STEPS = [
+  "locked",
+  "waiting",
+  "inspected",
+  "fragmented",
+  "scanning",
+  "repairing",
+  "reassembling",
+  "done",
+] as const satisfies readonly MissionStep[];
+const MISSION_STEP_VALUES: ReadonlySet<string> = new Set(MISSION_STEPS);
+
+export function isRepairMissionId(value: string): value is RepairMissionId {
+  return REPAIR_MISSION_ID_VALUES.has(value);
+}
+
+export function isMissionStep(value: string): value is MissionStep {
+  return MISSION_STEP_VALUES.has(value);
+}
+
+export function getNextMissionStep(step: MissionStep): MissionStep {
+  switch (step) {
+    case "locked":
+      return "waiting";
+    case "waiting":
+      return "inspected";
+    case "inspected":
+      return "fragmented";
+    case "fragmented":
+      return "scanning";
+    case "scanning":
+      return "repairing";
+    case "repairing":
+      return "reassembling";
+    case "reassembling":
+    case "done":
+      return "done";
+  }
+}
+
+export function getPreviousMissionStep(step: MissionStep): MissionStep {
+  switch (step) {
+    case "locked":
+    case "waiting":
+      return "locked";
+    case "inspected":
+      return "waiting";
+    case "fragmented":
+      return "inspected";
+    case "scanning":
+      return "fragmented";
+    case "repairing":
+      return "scanning";
+    case "reassembling":
+      return "repairing";
+    case "done":
+      return "reassembling";
+  }
+}

src/data/gameplay/repairMissions.ts

@@ -20,7 +20,7 @@ export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
     description:
       "Repair the damaged cooling module before relaunching the bike",
     modelPath: "/models/ebike/model.gltf",
-    modelScale: 0.5,
+    modelScale: 0.3,
     stageUiPath: "/assets/UI/ebike.webm",
     interactUiPath: REPAIR_INTERACT_UI_PATH,
     brokenUiPath: REPAIR_BROKEN_UI_PATH,
@@ -53,8 +53,8 @@ export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
       },
     ],
   },
-  pylone: {
-    id: "pylone",
+  pylon: {
+    id: "pylon",
     label: "Power pylon",
     description:
       "Restore the pylon lamp relay and damaged panel before reconnecting the grid",
@@ -64,17 +64,17 @@ export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
     brokenUiPath: REPAIR_BROKEN_UI_PATH,
     case: DEFAULT_REPAIR_CASE,
     reassemblySeconds: 1.8,
-    requiredReplacementPartId: "pylone-grid-relay-replacement",
+    requiredReplacementPartId: "pylon-grid-relay-replacement",
     scanPartSeconds: 1.4,
     brokenParts: [
       {
-        id: "pylone-grid-relay",
+        id: "pylon-grid-relay",
         label: "Grid relay",
         nodeName: "lampe",
         caseSlotName: "placeholder_1",
       },
       {
-        id: "pylone-damaged-panel",
+        id: "pylon-damaged-panel",
         label: "Damaged solar panel",
         nodeName: "panneau2",
         caseSlotName: "placeholder_2",
@@ -82,24 +82,24 @@ export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
     ],
     replacementParts: [
       {
-        id: "pylone-grid-relay-replacement",
+        id: "pylon-grid-relay-replacement",
         label: "Replacement grid relay",
         modelPath: "/models/pylone/model.gltf",
       },
       {
-        id: "pylone-stone-distractor",
+        id: "pylon-stone-distractor",
         label: "Stone counterweight",
         modelPath: "/models/galet/model.gltf",
       },
       {
-        id: "pylone-cooling-distractor",
+        id: "pylon-cooling-distractor",
         label: "Cooling core",
         modelPath: "/models/refroidisseur/model.gltf",
       },
     ],
   },
-  ferme: {
-    id: "ferme",
+  farm: {
+    id: "farm",
     label: "Vertical farm",
     description:
       "Stabilize the irrigation loop and humidity sensor before restarting the farm",
@@ -109,33 +109,33 @@ export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
     brokenUiPath: REPAIR_BROKEN_UI_PATH,
     case: DEFAULT_REPAIR_CASE,
     reassemblySeconds: 1.2,
-    requiredReplacementPartId: "ferme-irrigation-pump-replacement",
+    requiredReplacementPartId: "farm-irrigation-pump-replacement",
     scanPartSeconds: 0.9,
     brokenParts: [
       {
-        id: "ferme-irrigation-pump",
+        id: "farm-irrigation-pump",
         label: "Irrigation pump",
         caseSlotName: "placeholder_1",
       },
       {
-        id: "ferme-humidity-sensor",
+        id: "farm-humidity-sensor",
         label: "Humidity sensor",
         caseSlotName: "placeholder_2",
       },
     ],
     replacementParts: [
       {
-        id: "ferme-irrigation-pump-replacement",
+        id: "farm-irrigation-pump-replacement",
         label: "Replacement irrigation pump",
         modelPath: "/models/fermeverticale/model.gltf",
       },
       {
-        id: "ferme-tree-distractor",
+        id: "farm-tree-distractor",
         label: "Tree sensor",
         modelPath: "/models/sapin/model.gltf",
       },
       {
-        id: "ferme-radio-distractor",
+        id: "farm-radio-distractor",
         label: "Radio module",
         modelPath: "/models/talkie/model.gltf",
       },

src/data/handTrackingConfig.ts

@@ -1,6 +1,3 @@
-const HAND_TRACKING_LOCAL_WS_URL = "ws://localhost:8000/ws";
-const HAND_TRACKING_PROD_WS_URL = "wss://handtracking.la-fabrik.fr/ws";
-
 export const HAND_TRACKING_FRAME_WIDTH = 320;
 export const HAND_TRACKING_FRAME_HEIGHT = 240;
 export const HAND_TRACKING_TARGET_FPS = 10;
@@ -11,15 +8,3 @@ export const HAND_TRACKING_BROWSER_WASM_URL =
   "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.35/wasm";
 export const HAND_TRACKING_BROWSER_MODEL_URL =
   "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task";
-
-export function getHandTrackingWsUrl(): string {
-  const configuredUrl = import.meta.env.VITE_HAND_TRACKING_WS_URL;
-
-  if (configuredUrl) {
-    return configuredUrl;
-  }
-
-  return import.meta.env.DEV
-    ? HAND_TRACKING_LOCAL_WS_URL
-    : HAND_TRACKING_PROD_WS_URL;
-}

src/data/world/environmentConfig.ts

@@ -1,6 +1,4 @@
 export const GAME_SCENE_SKY_MODEL_PATH = "/models/skybox/model.gltf";
-export const GAME_SCENE_FALLBACK_SKY_MODEL_PATH = "/models/sky/model.glb";
 export const GAME_SCENE_SKY_MODEL_SCALE = 100;
-export const GAME_SCENE_FALLBACK_SKY_MODEL_SCALE = 1;
 export const GAME_SCENE_FALLBACK_BACKGROUND_COLOR = "#0b1018";
 export const PHYSICS_SCENE_BACKGROUND_COLOR = "#0b1018";

src/data/world/mapInstancingConfig.ts

@@ -2,6 +2,7 @@ export const MAP_INSTANCING_ASSETS = {
   boiteauxlettres: {
     mapName: "boiteauxlettres",
     modelPath: "/models/boiteauxlettres/model.gltf",
+    scaleMultiplier: 2,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -9,6 +10,7 @@ export const MAP_INSTANCING_ASSETS = {
   pylone: {
     mapName: "pylone",
     modelPath: "/models/pylone/model.gltf",
+    scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -16,6 +18,7 @@ export const MAP_INSTANCING_ASSETS = {
   immeuble1: {
     mapName: "immeuble1",
     modelPath: "/models/immeuble1/model.gltf",
+    scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -23,6 +26,7 @@ export const MAP_INSTANCING_ASSETS = {
   maison1: {
     mapName: "maison1",
     modelPath: "/models/maison1/model.gltf",
+    scaleMultiplier: 3,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -30,6 +34,7 @@ export const MAP_INSTANCING_ASSETS = {
   eolienne: {
     mapName: "eolienne",
     modelPath: "/models/eolienne/model.gltf",
+    scaleMultiplier: 0.85,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -37,6 +42,7 @@ export const MAP_INSTANCING_ASSETS = {
   parcebike: {
     mapName: "parcebike",
     modelPath: "/models/parcebike/model.gltf",
+    scaleMultiplier: 2,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -44,6 +50,7 @@ export const MAP_INSTANCING_ASSETS = {
   panneauaffichage: {
     mapName: "panneauaffichage",
     modelPath: "/models/panneauaffichage/model.gltf",
+    scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -51,6 +58,7 @@ export const MAP_INSTANCING_ASSETS = {
   panneauclassique: {
     mapName: "panneauclassique",
     modelPath: "/models/panneauclassique/model.gltf",
+    scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -58,6 +66,7 @@ export const MAP_INSTANCING_ASSETS = {
   panneaufleche: {
     mapName: "panneaufleche",
     modelPath: "/models/panneaufleche/model.gltf",
+    scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
@@ -65,12 +74,40 @@ export const MAP_INSTANCING_ASSETS = {
   panneausolaire: {
     mapName: "panneausolaire",
     modelPath: "/models/panneausolaire/model.gltf",
+    scaleMultiplier: 0.85,
     castShadow: true,
     receiveShadow: true,
     enabled: true,
   },
 } as const;
 
+export const MAP_SINGLE_MODEL_SCALE_MULTIPLIERS = {
+  ebike: 0.3,
+} as const satisfies Record<string, number>;
+
+export function getMapSingleModelScaleMultiplier(name: string): number {
+  return (
+    MAP_SINGLE_MODEL_SCALE_MULTIPLIERS[
+      name as keyof typeof MAP_SINGLE_MODEL_SCALE_MULTIPLIERS
+    ] ?? 1
+  );
+}
+
+export function getMapInstancedModelScaleMultiplier(name: string): number {
+  return (
+    Object.values(MAP_INSTANCING_ASSETS).find(
+      (config) => config.mapName === name,
+    )?.scaleMultiplier ?? 1
+  );
+}
+
+export function getMapModelScaleMultiplier(name: string): number {
+  return (
+    getMapSingleModelScaleMultiplier(name) *
+    getMapInstancedModelScaleMultiplier(name)
+  );
+}
+
 export const MAP_INSTANCING_ASSET_TYPES = [
   "boiteauxlettres",
   "pylone",
@@ -89,13 +126,3 @@ export type MapInstancingAssetType =
 
 export type MapInstancingAssetConfig =
   (typeof MAP_INSTANCING_ASSETS)[MapInstancingAssetType];
-
-const MAP_INSTANCED_NODE_NAMES: ReadonlySet<string> = new Set(
-  Object.values(MAP_INSTANCING_ASSETS)
-    .filter((config) => config.enabled)
-    .map((config) => config.mapName),
-);
-
-export function isInstancedMapNodeName(name: string): boolean {
-  return MAP_INSTANCED_NODE_NAMES.has(name);
-}

src/data/world/mapPerformanceConfig.ts

@@ -0,0 +1,100 @@
+export type MapPerformanceGroupName =
+  | "vegetation"
+  | "crops"
+  | "trees"
+  | "buildings"
+  | "landmarks"
+  | "props"
+  | "terrain"
+  | "sky";
+
+export type MapPerformanceModelName =
+  | "buisson"
+  | "arbre"
+  | "sapin"
+  | "champdeble"
+  | "champdesoja"
+  | "champsdetournesol"
+  | "potager"
+  | "ecole"
+  | "generateur"
+  | "fermeverticale"
+  | "lafabrik"
+  | "immeuble1"
+  | "eolienne"
+  | "pylone"
+  | "boiteauxlettres"
+  | "maison1"
+  | "panneauaffichage"
+  | "panneauclassique"
+  | "panneaufleche"
+  | "panneausolaire"
+  | "parcebike"
+  | "terrain"
+  | "sky";
+
+export const MAP_PERFORMANCE_GROUP_NAMES: readonly MapPerformanceGroupName[] = [
+  "vegetation",
+  "crops",
+  "trees",
+  "buildings",
+  "landmarks",
+  "props",
+  "terrain",
+  "sky",
+];
+
+export const MAP_PERFORMANCE_MODEL_NAMES: readonly MapPerformanceModelName[] = [
+  "buisson",
+  "arbre",
+  "sapin",
+  "champdeble",
+  "champdesoja",
+  "champsdetournesol",
+  "potager",
+  "ecole",
+  "generateur",
+  "fermeverticale",
+  "lafabrik",
+  "immeuble1",
+  "eolienne",
+  "pylone",
+  "boiteauxlettres",
+  "maison1",
+  "panneauaffichage",
+  "panneauclassique",
+  "panneaufleche",
+  "panneausolaire",
+  "parcebike",
+  "terrain",
+  "sky",
+];
+
+export const MAP_PERFORMANCE_MODEL_GROUPS: Record<
+  MapPerformanceModelName,
+  readonly MapPerformanceGroupName[]
+> = {
+  buisson: ["vegetation"],
+  arbre: ["vegetation", "trees"],
+  sapin: ["vegetation", "trees"],
+  champdeble: ["vegetation", "crops"],
+  champdesoja: ["vegetation", "crops"],
+  champsdetournesol: ["vegetation", "crops"],
+  potager: ["vegetation", "crops"],
+  ecole: ["buildings", "landmarks"],
+  generateur: ["landmarks"],
+  fermeverticale: ["buildings", "landmarks"],
+  lafabrik: ["buildings", "landmarks"],
+  immeuble1: ["buildings"],
+  eolienne: ["props"],
+  pylone: ["props"],
+  boiteauxlettres: ["props"],
+  maison1: ["buildings"],
+  panneauaffichage: ["props"],
+  panneauclassique: ["props"],
+  panneaufleche: ["props"],
+  panneausolaire: ["props"],
+  parcebike: ["props"],
+  terrain: ["terrain"],
+  sky: ["sky"],
+};

src/data/world/personnages/personnageConfig.ts

@@ -0,0 +1,53 @@
+import type { Vector3Tuple } from "@/types/three/three";
+
+export type PersonnageId = "electricienne" | "gerant" | "fermier";
+
+export interface PersonnageConfig {
+  id: PersonnageId;
+  label: string;
+  modelPath: string;
+  position: Vector3Tuple;
+  rotation: Vector3Tuple;
+  scale: Vector3Tuple;
+  animations: readonly string[];
+  defaultAnimation: string;
+}
+
+export const PERSONNAGE_CONFIGS = {
+  electricienne: {
+    id: "electricienne",
+    label: "Electricienne",
+    modelPath: "/models/electricienne-animated/model.gltf",
+    position: [-40.5, 0, 45.5],
+    rotation: [0, -0.35, 0],
+    scale: [1, 1, 1],
+    animations: ["Dance"],
+    defaultAnimation: "Dance",
+  },
+  gerant: {
+    id: "gerant",
+    label: "Gerant",
+    modelPath: "/models/gerant-animated/model.gltf",
+    position: [45.2, 0, 45.5],
+    rotation: [0, -1.55, 0],
+    scale: [1, 1, 1],
+    animations: ["idle", "walk"],
+    defaultAnimation: "idle",
+  },
+  fermier: {
+    id: "fermier",
+    label: "Fermier",
+    modelPath: "/models/fermier-animated/model.gltf",
+    position: [-6.5, 0, -69.5],
+    rotation: [0, -1.18, 0],
+    scale: [1, 1, 1],
+    animations: ["idle", "walk"],
+    defaultAnimation: "idle",
+  },
+} satisfies Record<PersonnageId, PersonnageConfig>;
+
+export const PERSONNAGE_IDS = [
+  "electricienne",
+  "gerant",
+  "fermier",
+] as const satisfies readonly PersonnageId[];

src/data/world/sceneLoadingConfig.ts

@@ -0,0 +1,7 @@
+import type { SceneLoadingState } from "@/types/world/sceneLoading";
+
+export const INITIAL_SCENE_LOADING_STATE: SceneLoadingState = {
+  currentStep: "Initialisation du jeu",
+  progress: 0,
+  status: "loading",
+};

src/data/world/terrainConfig.ts

@@ -1,15 +1,9 @@
-import type {
-  TerrainSurfaceColorConfig,
-  TerrainSurfaceProjectionConfig,
-} from "@/types/world/terrainSurface";
+import type { TerrainSurfaceColorConfig } from "@/types/world/terrainSurface";
 
 export const TERRAIN_MODEL_PATH = "/models/terrain/model.gltf";
 export const TERRAIN_WATER_HEIGHT = 0.8;
 
 export const TERRAIN_TILE_SIZE = 1;
-export const TERRAIN_SURFACE_COLOR_TOLERANCE = 5;
-export const TERRAIN_SURFACE_PROJECTION =
-  {} satisfies TerrainSurfaceProjectionConfig;
 
 export const TERRAIN_COLORS = {
   grass1: {
@@ -60,5 +54,3 @@ export const TERRAIN_COLORS = {
     kind: "rock",
   },
 } satisfies Record<string, TerrainSurfaceColorConfig>;
-
-export type TerrainColorKey = keyof typeof TERRAIN_COLORS;

src/data/world/vegetationConfig.ts

@@ -2,19 +2,21 @@ export const VEGETATION_TYPES = {
   buissons: {
     mapName: "buisson",
     modelPath: "/models/buisson/model.gltf",
-    scaleMultiplier: 2,
+    scaleMultiplier: 1.5,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.08,
+    windStrength: 0.06,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
   sapin: {
     mapName: "sapin",
     modelPath: "/models/sapin/model.gltf",
-    scaleMultiplier: 5,
+    scaleMultiplier: 4,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.04,
+    windStrength: 0.12,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
   arbre: {
@@ -23,7 +25,8 @@ export const VEGETATION_TYPES = {
     scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.06,
+    windStrength: 0.15,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
   champdeble: {
@@ -32,7 +35,8 @@ export const VEGETATION_TYPES = {
     scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.18,
+    windStrength: 0.15,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
   champdesoja: {
@@ -41,7 +45,8 @@ export const VEGETATION_TYPES = {
     scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.16,
+    windStrength: 0.15,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
   champsdetournesol: {
@@ -50,7 +55,18 @@ export const VEGETATION_TYPES = {
     scaleMultiplier: 1,
     castShadow: true,
     receiveShadow: true,
-    windStrength: 0.14,
+    windStrength: 0.15,
+    rotationOffset: [0, 0, 0],
+    enabled: true,
+  },
+  potager: {
+    mapName: "potager",
+    modelPath: "/models/potager/potager.gltf",
+    scaleMultiplier: 1,
+    castShadow: true,
+    receiveShadow: true,
+    windStrength: 0,
+    rotationOffset: [0, 0, 0],
     enabled: true,
   },
 } as const;
@@ -62,10 +78,18 @@ export const VEGETATION_TYPE_KEYS = [
   "champdeble",
   "champdesoja",
   "champsdetournesol",
+  "potager",
 ] as const satisfies readonly (keyof typeof VEGETATION_TYPES)[];
 
 export type VegetationType = (typeof VEGETATION_TYPE_KEYS)[number];
 
+export function getVegetationModelScaleMultiplier(name: string): number {
+  return (
+    Object.values(VEGETATION_TYPES).find((config) => config.mapName === name)
+      ?.scaleMultiplier ?? 1
+  );
+}
+
 export const INSTANCED_MAP_EXCEPTIONS = new Set([
   "Scene",
   "blocking",

src/data/world/windConfig.ts

@@ -13,12 +13,3 @@ export const WIND_BOUNDS = {
 };
 
 export type WindState = typeof WIND_DEFAULTS;
-
-export function getWindVector(wind: WindState): { x: number; z: number } {
-  const intensity = wind.speed * wind.strength;
-
-  return {
-    x: Math.cos(wind.direction) * intensity,
-    z: Math.sin(wind.direction) * intensity,
-  };
-}

src/hooks/debug/usePersonnageDebug.ts

@@ -0,0 +1,108 @@
+import { useDebugFolder } from "@/hooks/debug/useDebugFolder";
+import {
+  PERSONNAGE_CONFIGS,
+  PERSONNAGE_IDS,
+} from "@/data/world/personnages/personnageConfig";
+import { usePersonnageDebugStore } from "@/managers/stores/usePersonnageDebugStore";
+
+function createAnimationOptions(
+  animations: readonly string[],
+): Record<string, string> {
+  if (animations.length === 0) {
+    return { None: "" };
+  }
+
+  return Object.fromEntries(
+    animations.map((animation) => [animation || "None", animation]),
+  );
+}
+
+export function usePersonnageDebug(): void {
+  useDebugFolder("Personnages", (folder) => {
+    const store = usePersonnageDebugStore.getState();
+
+    for (const id of PERSONNAGE_IDS) {
+      const config = PERSONNAGE_CONFIGS[id];
+      const state = store.personnages[id];
+      const characterFolder = folder.addFolder(config.label);
+      const controls = {
+        animation: state.animation,
+        positionX: state.position[0],
+        positionY: state.position[1],
+        positionZ: state.position[2],
+        rotationX: state.rotation[0],
+        rotationY: state.rotation[1],
+        rotationZ: state.rotation[2],
+        scaleX: state.scale[0],
+        scaleY: state.scale[1],
+        scaleZ: state.scale[2],
+      };
+
+      characterFolder
+        .add(controls, "animation", createAnimationOptions(config.animations))
+        .name("Animation")
+        .onChange((animation: string) => {
+          usePersonnageDebugStore.getState().setAnimation(id, animation);
+        });
+
+      characterFolder
+        .add(controls, "positionX", -120, 120, 0.1)
+        .name("Position X")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setPosition(id, 0, value);
+        });
+      characterFolder
+        .add(controls, "positionY", -20, 40, 0.1)
+        .name("Position Y")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setPosition(id, 1, value);
+        });
+      characterFolder
+        .add(controls, "positionZ", -120, 120, 0.1)
+        .name("Position Z")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setPosition(id, 2, value);
+        });
+
+      characterFolder
+        .add(controls, "rotationX", -Math.PI, Math.PI, 0.01)
+        .name("Rotation X")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setRotation(id, 0, value);
+        });
+      characterFolder
+        .add(controls, "rotationY", -Math.PI, Math.PI, 0.01)
+        .name("Rotation Y")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setRotation(id, 1, value);
+        });
+      characterFolder
+        .add(controls, "rotationZ", -Math.PI, Math.PI, 0.01)
+        .name("Rotation Z")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setRotation(id, 2, value);
+        });
+
+      characterFolder
+        .add(controls, "scaleX", 0.1, 5, 0.05)
+        .name("Scale X")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setScale(id, 0, value);
+        });
+      characterFolder
+        .add(controls, "scaleY", 0.1, 5, 0.05)
+        .name("Scale Y")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setScale(id, 1, value);
+        });
+      characterFolder
+        .add(controls, "scaleZ", 0.1, 5, 0.05)
+        .name("Scale Z")
+        .onChange((value: number) => {
+          usePersonnageDebugStore.getState().setScale(id, 2, value);
+        });
+
+      characterFolder.close();
+    }
+  });
+}

src/hooks/gameplay/useRepairMovementLocked.ts

@@ -6,10 +6,10 @@ export function useRepairMovementLocked(): boolean {
     switch (state.mainState) {
       case "ebike":
         return isRepairMovementLocked(state.ebike.currentStep);
-      case "pylone":
-        return isRepairMovementLocked(state.pylone.currentStep);
-      case "ferme":
-        return isRepairMovementLocked(state.ferme.currentStep);
+      case "pylon":
+        return isRepairMovementLocked(state.pylon.currentStep);
+      case "farm":
+        return isRepairMovementLocked(state.farm.currentStep);
       case "intro":
       case "outro":
         return false;
@@ -23,6 +23,7 @@ function isRepairMovementLocked(step: MissionStep): boolean {
     step === "fragmented" ||
     step === "scanning" ||
     step === "repairing" ||
-    step === "reassembling"
+    step === "reassembling" ||
+    step === "done"
   );
 }

src/hooks/handTracking/useRemoteHandTracking.ts

@@ -5,8 +5,8 @@ import {
   HAND_TRACKING_JPEG_QUALITY,
   HAND_TRACKING_RESPONSE_TIMEOUT_MS,
   HAND_TRACKING_TARGET_FPS,
-  getHandTrackingWsUrl,
 } from "@/data/handTrackingConfig";
+import { getHandTrackingWsUrl } from "@/utils/handTracking/handTrackingEndpoint";
 import {
   INITIAL_HAND_TRACKING_SNAPSHOT,
   getCameraStreamWithTimeout,

src/hooks/three/useClonedObject.ts

@@ -1,15 +1,6 @@
-import { useEffect, useMemo } from "react";
+import { useMemo } from "react";
 import * as THREE from "three";
-import { disposeObject3D } from "@/utils/three/dispose";
 
 export function useClonedObject<T extends THREE.Object3D>(object: T): T {
-  const clone = useMemo(() => object.clone(true) as T, [object]);
-
-  useEffect(() => {
-    return () => {
-      disposeObject3D(clone);
-    };
-  }, [clone]);
-
-  return clone;
+  return useMemo(() => object.clone(true) as T, [object]);
 }

src/hooks/three/useTerrainHeight.ts

@@ -16,6 +16,24 @@ interface TerrainHeightSampler {
   getHeight: (x: number, z: number) => number | null;
 }
 
+interface CachedTerrainHeightSampler {
+  key: string;
+  sampler: TerrainHeightSampler;
+}
+
+const terrainSamplerCache = new WeakMap<
+  THREE.Object3D,
+  CachedTerrainHeightSampler
+>();
+
+function createTerrainSamplerCacheKey(
+  position: Vector3Tuple,
+  rotation: Vector3Tuple,
+  scale: Vector3Tuple,
+): string {
+  return `${position.join(",")}|${rotation.join(",")}|${scale.join(",")}`;
+}
+
 function createTerrainHeightSampler(
   scene: THREE.Object3D,
   position: Vector3Tuple,
@@ -64,10 +82,23 @@ export function useTerrainHeightSampler(): TerrainHeightSampler {
   const rotation = terrainNode?.rotation ?? DEFAULT_TERRAIN_ROTATION;
   const scale = terrainNode?.scale ?? DEFAULT_TERRAIN_SCALE;
 
-  return useMemo(
-    () => createTerrainHeightSampler(scene, position, rotation, scale),
-    [position, rotation, scale, scene],
-  );
+  return useMemo(() => {
+    const key = createTerrainSamplerCacheKey(position, rotation, scale);
+    const cached = terrainSamplerCache.get(scene);
+
+    if (cached?.key === key) {
+      return cached.sampler;
+    }
+
+    const sampler = createTerrainHeightSampler(
+      scene,
+      position,
+      rotation,
+      scale,
+    );
+    terrainSamplerCache.set(scene, { key, sampler });
+    return sampler;
+  }, [position, rotation, scale, scene]);
 }
 
 export function useTerrainSnappedPosition(

src/hooks/useActivityCity.ts

@@ -1,5 +0,0 @@
-import { useGameStore } from "@/managers/stores/useGameStore";
-
-export function useActivityCity(): boolean {
-  return useGameStore((state) => state.missionFlow.activityCity);
-}

src/hooks/world/useMapInstancingData.ts

@@ -4,16 +4,11 @@ import {
   MAP_INSTANCING_ASSET_TYPES,
   type MapInstancingAssetType,
 } from "@/data/world/mapInstancingConfig";
-import type { MapNode } from "@/types/map/mapScene";
-import {
-  type MapNodeInstanceTransform,
-  mapNodeToInstanceTransform,
-} from "@/utils/map/mapInstanceTransform";
+import type { MapAssetInstance, MapNode } from "@/types/map/mapScene";
+import { mapNodeToInstanceTransform } from "@/utils/map/mapInstanceTransform";
 import { logger } from "@/utils/core/Logger";
 import { getMapNodes, loadMapSceneData } from "@/utils/map/loadMapSceneData";
 
-export type MapAssetInstance = MapNodeInstanceTransform;
-
 export type MapInstancingData = Map<MapInstancingAssetType, MapAssetInstance[]>;
 
 function extractMapInstancingData(mapNodes: MapNode[]): MapInstancingData {
@@ -65,6 +60,11 @@ export function useMapInstancingData(): {
         logger.error("MapInstancing", "Failed to load map instancing data", {
           error: error instanceof Error ? error : String(error),
         });
+        if (!cancelled) {
+          setData(null);
+          setIsLoading(false);
+        }
+        return;
       }
 
       const nodes = getMapNodes();

src/hooks/world/useTerrainSurfaceData.ts

@@ -1,64 +0,0 @@
-import { useMemo } from "react";
-import * as THREE from "three";
-import { useGLTF } from "@react-three/drei";
-import { TERRAIN_MODEL_PATH } from "@/data/world/terrainConfig";
-import type {
-  TerrainSurfaceBounds,
-  TerrainSurfaceData,
-} from "@/types/world/terrainSurface";
-import { createTerrainSurfaceImageData } from "@/utils/world/terrainSurfaceSampler";
-
-function findTerrainBaseColorTexture(
-  scene: THREE.Object3D,
-): THREE.Texture | null {
-  let texture: THREE.Texture | null = null;
-
-  scene.traverse((child) => {
-    if (texture || !(child instanceof THREE.Mesh)) return;
-
-    const materials = Array.isArray(child.material)
-      ? child.material
-      : [child.material];
-
-    for (const material of materials) {
-      if (material instanceof THREE.MeshStandardMaterial && material.map) {
-        texture = material.map;
-        return;
-      }
-    }
-  });
-
-  return texture;
-}
-
-function createTerrainSurfaceBounds(
-  scene: THREE.Object3D,
-): TerrainSurfaceBounds {
-  scene.updateWorldMatrix(true, true);
-
-  const box = new THREE.Box3().setFromObject(scene);
-  return {
-    minX: box.min.x,
-    maxX: box.max.x,
-    minZ: box.min.z,
-    maxZ: box.max.z,
-  };
-}
-
-export function useTerrainSurfaceData(): TerrainSurfaceData | null {
-  const { scene } = useGLTF(TERRAIN_MODEL_PATH);
-
-  return useMemo(() => {
-    const texture = findTerrainBaseColorTexture(scene);
-    if (!texture) return null;
-
-    const imageData = createTerrainSurfaceImageData(texture);
-    if (!imageData) return null;
-
-    return {
-      bounds: createTerrainSurfaceBounds(scene),
-      imageData,
-      raycastTarget: scene,
-    };
-  }, [scene]);
-}

src/hooks/world/useVegetationData.ts

@@ -1,14 +1,14 @@
 import { useEffect, useState } from "react";
-import { INSTANCED_MAP_EXCEPTIONS } from "@/world/vegetation/vegetationConfig";
-import type { MapNode } from "@/types/map/mapScene";
-import {
-  type MapNodeInstanceTransform,
-  mapNodeToInstanceTransform,
-} from "@/utils/map/mapInstanceTransform";
+import { INSTANCED_MAP_EXCEPTIONS } from "@/data/world/vegetationConfig";
+import type { MapNode, VegetationInstance } from "@/types/map/mapScene";
+import { mapNodeToInstanceTransform } from "@/utils/map/mapInstanceTransform";
 import { logger } from "@/utils/core/Logger";
 import { loadMapSceneData } from "@/utils/map/loadMapSceneData";
-
-export type VegetationInstance = MapNodeInstanceTransform;
+import {
+  createPotagerMapNode,
+  isPotagerSourceMapNode,
+  POTAGER_MAP_NAME,
+} from "@/utils/map/potagerMapNodes";
 
 interface InstancedMapEntry {
   modelPath: string;
@@ -17,12 +17,35 @@ interface InstancedMapEntry {
 
 export type VegetationData = Map<string, InstancedMapEntry>;
 
+function createPositionKey(node: MapNode): string {
+  return node.position.map((value) => value.toFixed(3)).join(":");
+}
+
 function extractVegetationData(
   mapNodes: MapNode[],
   models: Map<string, string>,
 ): VegetationData {
   const data: VegetationData = new Map();
 
+  function addInstance(
+    mapName: string,
+    modelPath: string,
+    node: MapNode,
+  ): void {
+    const entry = data.get(mapName);
+    const instance = mapNodeToInstanceTransform(node);
+
+    if (entry) {
+      entry.instances.push(instance);
+      return;
+    }
+
+    data.set(mapName, {
+      modelPath,
+      instances: [instance],
+    });
+  }
+
   for (const node of mapNodes) {
     if (node.type !== "Object3D") continue;
     if (INSTANCED_MAP_EXCEPTIONS.has(node.name)) continue;
@@ -30,16 +53,36 @@ function extractVegetationData(
     const modelPath = models.get(node.name);
     if (!modelPath) continue;
 
-    const entry = data.get(node.name);
+    addInstance(node.name, modelPath, node);
+  }
 
-    if (entry) {
-      entry.instances.push(mapNodeToInstanceTransform(node));
-    } else {
-      data.set(node.name, {
-        modelPath,
-        instances: [mapNodeToInstanceTransform(node)],
-      });
+  const existingPotagerPositionKeys = new Set(
+    mapNodes
+      .filter((node) => node.name === POTAGER_MAP_NAME)
+      .map(createPositionKey),
+  );
+
+  for (const node of mapNodes) {
+    if (!isPotagerSourceMapNode(node)) continue;
+    if (existingPotagerPositionKeys.has(createPositionKey(node))) continue;
+
+    addInstance(
+      POTAGER_MAP_NAME,
+      "/models/potager/potager.gltf",
+      createPotagerMapNode(node),
+    );
+  }
+
+  const potagerEntry = data.get(POTAGER_MAP_NAME);
+  if (potagerEntry) {
+    const uniqueInstances = new Map<string, VegetationInstance>();
+    for (const instance of potagerEntry.instances) {
+      uniqueInstances.set(
+        instance.position.map((value) => value.toFixed(3)).join(":"),
+        instance,
+      );
     }
+    potagerEntry.instances = [...uniqueInstances.values()];
   }
 
   return data;
@@ -64,6 +107,11 @@ export function useVegetationData(): {
         logger.error("Vegetation", "Failed to load vegetation data", {
           error: error instanceof Error ? error : String(error),
         });
+        if (!cancelled) {
+          setData(null);
+          setIsLoading(false);
+        }
+        return;
       }
 
       if (!cancelled) {

src/hooks/world/useVisibleWorldChunks.ts

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
 import { useFrame, useThree } from "@react-three/fiber";
 import { CHUNK_CONFIG } from "@/data/world/chunkStreamingConfig";
 
@@ -18,6 +18,7 @@ export function useVisibleWorldChunks<TChunk extends WorldChunkLike>(
 ): readonly TChunk[] {
   const camera = useThree((state) => state.camera);
   const lastUpdateRef = useRef(-CHUNK_CONFIG.updateInterval);
+  const activeChunkKeysRef = useRef<Set<string>>(new Set());
   const [activeChunkKeys, setActiveChunkKeys] = useState<Set<string>>(
     () => new Set(),
   );
@@ -32,7 +33,7 @@ export function useVisibleWorldChunks<TChunk extends WorldChunkLike>(
         chunk.centerX - cameraX,
         chunk.centerZ - cameraZ,
       );
-      const wasActive = activeChunkKeys.has(chunk.key);
+      const wasActive = activeChunkKeysRef.current.has(chunk.key);
       const radius = wasActive
         ? CHUNK_CONFIG.unloadRadius
         : CHUNK_CONFIG.loadRadius;
@@ -42,10 +43,11 @@ export function useVisibleWorldChunks<TChunk extends WorldChunkLike>(
       }
     }
 
-    if (areSetsEqual(nextKeys, activeChunkKeys)) return;
+    if (areSetsEqual(nextKeys, activeChunkKeysRef.current)) return;
 
+    activeChunkKeysRef.current = nextKeys;
     setActiveChunkKeys(nextKeys);
-  }, [activeChunkKeys, camera, chunks]);
+  }, [camera, chunks]);
 
   useFrame(({ clock }) => {
     if (!streamingEnabled) return;
@@ -57,18 +59,26 @@ export function useVisibleWorldChunks<TChunk extends WorldChunkLike>(
     updateActiveChunks();
   });
 
-  if (!streamingEnabled) return chunks;
+  return useMemo(() => {
+    if (!streamingEnabled) return chunks;
 
-  return chunks.filter((chunk) => {
-    if (activeChunkKeys.size > 0) {
-      return activeChunkKeys.has(chunk.key);
-    }
+    return chunks.filter((chunk) => {
+      if (activeChunkKeys.size > 0) {
+        return activeChunkKeys.has(chunk.key);
+      }
 
-    return (
-      Math.hypot(
-        chunk.centerX - camera.position.x,
-        chunk.centerZ - camera.position.z,
-      ) <= CHUNK_CONFIG.loadRadius
-    );
-  });
+      return (
+        Math.hypot(
+          chunk.centerX - camera.position.x,
+          chunk.centerZ - camera.position.z,
+        ) <= CHUNK_CONFIG.loadRadius
+      );
+    });
+  }, [
+    activeChunkKeys,
+    camera.position.x,
+    camera.position.z,
+    chunks,
+    streamingEnabled,
+  ]);
 }

src/managers/AudioManager.ts

@@ -1,18 +1,16 @@
+import {
+  DEFAULT_CATEGORY_VOLUMES,
+  type AudioCategory,
+} from "@/data/audioConfig";
 import { logger } from "@/utils/core/Logger";
 
-export type AudioCategory = "music" | "sfx" | "dialogue";
+export type { AudioCategory } from "@/data/audioConfig";
 export type OneShotAudioCategory = Exclude<AudioCategory, "music">;
 
 interface AudioContextWindow extends Window {
   webkitAudioContext?: typeof AudioContext;
 }
 
-const DEFAULT_CATEGORY_VOLUMES: Record<AudioCategory, number> = {
-  music: 1,
-  sfx: 1,
-  dialogue: 1,
-};
-
 interface PlaySoundOptions {
   category?: OneShotAudioCategory;
   pan?: number;

src/managers/stores/useGameStore.ts

@@ -1,15 +1,13 @@
 import { create } from "zustand";
+import { isGameStep, isMainGameState } from "@/data/game/gameStateConfig";
 import {
-  isGameStep,
-  isMainGameState,
-  type GameStep,
-  type MainGameState,
-} from "@/types/game";
-import {
-  isRepairMissionId,
-  isMissionStep,
   getNextMissionStep,
   getPreviousMissionStep,
+  isMissionStep,
+  isRepairMissionId,
+} from "@/data/gameplay/repairMissionState";
+import type { GameStep, MainGameState } from "@/types/game";
+import {
   type MissionStep,
   type RepairMissionId,
 } from "@/types/gameplay/repairMission";
@@ -49,10 +47,10 @@ export interface GameState {
   ebike: MissionState & {
     isRepaired: boolean;
   };
-  pylone: MissionState & {
+  pylon: MissionState & {
     isPowered: boolean;
   };
-  ferme: MissionState & {
+  farm: MissionState & {
     irrigationFixed: boolean;
   };
   outro: {
@@ -71,14 +69,14 @@ interface GameActions {
   setIntroState: (intro: Partial<IntroState>) => void;
   setPlayerName: (playerName: string) => void;
   setEbikeState: (ebike: Partial<GameState["ebike"]>) => void;
-  setPyloneState: (pylone: Partial<GameState["pylone"]>) => void;
-  setFermeState: (ferme: Partial<GameState["ferme"]>) => void;
+  setPylonState: (pylon: Partial<GameState["pylon"]>) => void;
+  setFarmState: (farm: Partial<GameState["farm"]>) => void;
   setOutroState: (outro: Partial<GameState["outro"]>) => void;
   setMissionStep: (mission: RepairMissionId, step: MissionStep) => void;
   completeIntro: () => void;
   completeEbike: () => void;
-  completePylone: () => void;
-  completeFerme: () => void;
+  completePylon: () => void;
+  completeFarm: () => void;
   completeMission: (mission: RepairMissionId) => void;
   startOutro: () => void;
   advanceGameState: () => void;
@@ -110,6 +108,10 @@ function completeIntroState(state: GameState): GameStateUpdate {
       hasCompleted: true,
       isEbikeUnlocked: true,
     },
+    missionFlow: {
+      ...state.missionFlow,
+      canMove: true,
+    },
     ebike: {
       ...state.ebike,
       currentStep: "locked",
@@ -119,39 +121,39 @@ function completeIntroState(state: GameState): GameStateUpdate {
 
 function completeEbikeState(state: GameState): GameStateUpdate {
   return {
-    mainState: "pylone",
+    mainState: "pylon",
     ebike: {
       ...state.ebike,
       currentStep: "done",
       isRepaired: true,
     },
-    pylone: {
-      ...state.pylone,
+    pylon: {
+      ...state.pylon,
       currentStep: "waiting",
     },
   };
 }
 
-function completePyloneState(state: GameState): GameStateUpdate {
+function completePylonState(state: GameState): GameStateUpdate {
   return {
-    mainState: "ferme",
-    pylone: {
-      ...state.pylone,
+    mainState: "farm",
+    pylon: {
+      ...state.pylon,
       currentStep: "done",
       isPowered: true,
     },
-    ferme: {
-      ...state.ferme,
+    farm: {
+      ...state.farm,
       currentStep: "waiting",
     },
   };
 }
 
-function completeFermeState(state: GameState): GameStateUpdate {
+function completeFarmState(state: GameState): GameStateUpdate {
   return {
     mainState: "outro",
-    ferme: {
-      ...state.ferme,
+    farm: {
+      ...state.farm,
       currentStep: "done",
       irrigationFixed: true,
     },
@@ -182,10 +184,10 @@ function completeMissionState(
   switch (mission) {
     case "ebike":
       return completeEbikeState(state);
-    case "pylone":
-      return completePyloneState(state);
-    case "ferme":
-      return completeFermeState(state);
+    case "pylon":
+      return completePylonState(state);
+    case "farm":
+      return completeFarmState(state);
   }
 }
 
@@ -243,12 +245,12 @@ function createInitialGameState(): GameState {
       dialogueAudio: null,
       isRepaired: false,
     },
-    pylone: {
+    pylon: {
       currentStep: "locked",
       dialogueAudio: null,
       isPowered: false,
     },
-    ferme: {
+    farm: {
       currentStep: "locked",
       dialogueAudio: null,
       irrigationFixed: false,
@@ -321,8 +323,8 @@ function hydrateDebugGameState(initial: GameState, value: unknown): GameState {
   if (!isRecord(value)) return initial;
 
   const ebike = hydrateMissionState(initial.ebike, value.ebike);
-  const pylone = hydrateMissionState(initial.pylone, value.pylone);
-  const ferme = hydrateMissionState(initial.ferme, value.ferme);
+  const pylon = hydrateMissionState(initial.pylon, value.pylon);
+  const farm = hydrateMissionState(initial.farm, value.farm);
   const outro = isRecord(value.outro) ? value.outro : null;
 
   return {
@@ -344,19 +346,19 @@ function hydrateDebugGameState(initial: GameState, value: unknown): GameState {
           ? value.ebike.isRepaired
           : initial.ebike.isRepaired,
     },
-    pylone: {
-      ...pylone,
+    pylon: {
+      ...pylon,
       isPowered:
-        isRecord(value.pylone) && isBoolean(value.pylone.isPowered)
-          ? value.pylone.isPowered
-          : initial.pylone.isPowered,
+        isRecord(value.pylon) && isBoolean(value.pylon.isPowered)
+          ? value.pylon.isPowered
+          : initial.pylon.isPowered,
     },
-    ferme: {
-      ...ferme,
+    farm: {
+      ...farm,
       irrigationFixed:
-        isRecord(value.ferme) && isBoolean(value.ferme.irrigationFixed)
-          ? value.ferme.irrigationFixed
-          : initial.ferme.irrigationFixed,
+        isRecord(value.farm) && isBoolean(value.farm.irrigationFixed)
+          ? value.farm.irrigationFixed
+          : initial.farm.irrigationFixed,
     },
     outro: {
       dialogueAudio:
@@ -385,8 +387,8 @@ function pickGameState(state: GameStore): GameState {
     missionFlow: state.missionFlow,
     intro: state.intro,
     ebike: state.ebike,
-    pylone: state.pylone,
-    ferme: state.ferme,
+    pylon: state.pylon,
+    farm: state.farm,
     outro: state.outro,
   };
 }
@@ -417,18 +419,18 @@ export const useGameStore = create<GameStore>()((set) => ({
     })),
   setEbikeState: (ebike) =>
     set((state) => ({ ebike: { ...state.ebike, ...ebike } })),
-  setPyloneState: (pylone) =>
-    set((state) => ({ pylone: { ...state.pylone, ...pylone } })),
-  setFermeState: (ferme) =>
-    set((state) => ({ ferme: { ...state.ferme, ...ferme } })),
+  setPylonState: (pylon) =>
+    set((state) => ({ pylon: { ...state.pylon, ...pylon } })),
+  setFarmState: (farm) =>
+    set((state) => ({ farm: { ...state.farm, ...farm } })),
   setOutroState: (outro) =>
     set((state) => ({ outro: { ...state.outro, ...outro } })),
   setMissionStep: (mission, step) =>
     set((state) => setMissionStepState(state, mission, step)),
   completeIntro: () => set(completeIntroState),
   completeEbike: () => set((state) => completeMissionState(state, "ebike")),
-  completePylone: () => set((state) => completeMissionState(state, "pylone")),
-  completeFerme: () => set((state) => completeMissionState(state, "ferme")),
+  completePylon: () => set((state) => completeMissionState(state, "pylon")),
+  completeFarm: () => set((state) => completeMissionState(state, "farm")),
   completeMission: (mission) =>
     set((state) => completeMissionState(state, mission)),
   startOutro: () => set(startOutroState),

src/managers/stores/useMapPerformanceStore.ts

@@ -1,38 +1,18 @@
 import { create } from "zustand";
+import {
+  MAP_PERFORMANCE_GROUP_NAMES,
+  MAP_PERFORMANCE_MODEL_GROUPS,
+  MAP_PERFORMANCE_MODEL_NAMES,
+  type MapPerformanceGroupName,
+  type MapPerformanceModelName,
+} from "@/data/world/mapPerformanceConfig";
 
-export type MapPerformanceGroupName =
-  | "vegetation"
-  | "crops"
-  | "trees"
-  | "buildings"
-  | "landmarks"
-  | "props"
-  | "terrain"
-  | "sky";
-
-export type MapPerformanceModelName =
-  | "buisson"
-  | "arbre"
-  | "sapin"
-  | "champdeble"
-  | "champdesoja"
-  | "champsdetournesol"
-  | "ecole"
-  | "generateur"
-  | "fermeverticale"
-  | "lafabrik"
-  | "immeuble1"
-  | "eolienne"
-  | "pylone"
-  | "boiteauxlettres"
-  | "maison1"
-  | "panneauaffichage"
-  | "panneauclassique"
-  | "panneaufleche"
-  | "panneausolaire"
-  | "parcebike"
-  | "terrain"
-  | "sky";
+export {
+  MAP_PERFORMANCE_GROUP_NAMES,
+  MAP_PERFORMANCE_MODEL_NAMES,
+  type MapPerformanceGroupName,
+  type MapPerformanceModelName,
+};
 
 export interface MapPerformanceVisibility {
   groups: Record<MapPerformanceGroupName, boolean>;
@@ -47,70 +27,6 @@ interface MapPerformanceActions {
 
 type MapPerformanceStore = MapPerformanceVisibility & MapPerformanceActions;
 
-export const MAP_PERFORMANCE_GROUP_NAMES: readonly MapPerformanceGroupName[] = [
-  "vegetation",
-  "crops",
-  "trees",
-  "buildings",
-  "landmarks",
-  "props",
-  "terrain",
-  "sky",
-];
-
-export const MAP_PERFORMANCE_MODEL_NAMES: readonly MapPerformanceModelName[] = [
-  "buisson",
-  "arbre",
-  "sapin",
-  "champdeble",
-  "champdesoja",
-  "champsdetournesol",
-  "ecole",
-  "generateur",
-  "fermeverticale",
-  "lafabrik",
-  "immeuble1",
-  "eolienne",
-  "pylone",
-  "boiteauxlettres",
-  "maison1",
-  "panneauaffichage",
-  "panneauclassique",
-  "panneaufleche",
-  "panneausolaire",
-  "parcebike",
-  "terrain",
-  "sky",
-];
-
-const MODEL_GROUPS: Record<
-  MapPerformanceModelName,
-  readonly MapPerformanceGroupName[]
-> = {
-  buisson: ["vegetation"],
-  arbre: ["vegetation", "trees"],
-  sapin: ["vegetation", "trees"],
-  champdeble: ["vegetation", "crops"],
-  champdesoja: ["vegetation", "crops"],
-  champsdetournesol: ["vegetation", "crops"],
-  ecole: ["buildings", "landmarks"],
-  generateur: ["landmarks"],
-  fermeverticale: ["buildings", "landmarks"],
-  lafabrik: ["buildings", "landmarks"],
-  immeuble1: ["buildings"],
-  eolienne: ["props"],
-  pylone: ["props"],
-  boiteauxlettres: ["props"],
-  maison1: ["buildings"],
-  panneauaffichage: ["props"],
-  panneauclassique: ["props"],
-  panneaufleche: ["props"],
-  panneausolaire: ["props"],
-  parcebike: ["props"],
-  terrain: ["terrain"],
-  sky: ["sky"],
-};
-
 function createVisibleRecord<T extends string>(
   keys: readonly T[],
 ): Record<T, boolean> {
@@ -140,7 +56,9 @@ export function isMapModelVisible(
   if (!isMapPerformanceModelName(name)) return true;
   if (!visibility.models[name]) return false;
 
-  return MODEL_GROUPS[name].every((group) => visibility.groups[group]);
+  return MAP_PERFORMANCE_MODEL_GROUPS[name].every(
+    (group) => visibility.groups[group],
+  );
 }
 
 export const useMapPerformanceStore = create<MapPerformanceStore>()((set) => ({

src/managers/stores/usePersonnageDebugStore.ts

@@ -0,0 +1,89 @@
+import { create } from "zustand";
+import {
+  PERSONNAGE_CONFIGS,
+  PERSONNAGE_IDS,
+  type PersonnageId,
+} from "@/data/world/personnages/personnageConfig";
+import type { Vector3Tuple } from "@/types/three/three";
+
+interface PersonnageDebugState {
+  animation: string;
+  position: Vector3Tuple;
+  rotation: Vector3Tuple;
+  scale: Vector3Tuple;
+}
+
+interface PersonnageDebugStore {
+  personnages: Record<PersonnageId, PersonnageDebugState>;
+  setAnimation: (id: PersonnageId, animation: string) => void;
+  setPosition: (id: PersonnageId, axis: 0 | 1 | 2, value: number) => void;
+  setRotation: (id: PersonnageId, axis: 0 | 1 | 2, value: number) => void;
+  setScale: (id: PersonnageId, axis: 0 | 1 | 2, value: number) => void;
+}
+
+function updateVector(
+  vector: Vector3Tuple,
+  axis: 0 | 1 | 2,
+  value: number,
+): Vector3Tuple {
+  const next: Vector3Tuple = [...vector];
+  next[axis] = value;
+  return next;
+}
+
+const initialPersonnages = Object.fromEntries(
+  PERSONNAGE_IDS.map((id) => {
+    const config = PERSONNAGE_CONFIGS[id];
+
+    return [
+      id,
+      {
+        animation: config.defaultAnimation,
+        position: [...config.position],
+        rotation: [...config.rotation],
+        scale: [...config.scale],
+      },
+    ];
+  }),
+) as Record<PersonnageId, PersonnageDebugState>;
+
+export const usePersonnageDebugStore = create<PersonnageDebugStore>((set) => ({
+  personnages: initialPersonnages,
+  setAnimation: (id, animation) =>
+    set((state) => ({
+      personnages: {
+        ...state.personnages,
+        [id]: { ...state.personnages[id], animation },
+      },
+    })),
+  setPosition: (id, axis, value) =>
+    set((state) => ({
+      personnages: {
+        ...state.personnages,
+        [id]: {
+          ...state.personnages[id],
+          position: updateVector(state.personnages[id].position, axis, value),
+        },
+      },
+    })),
+  setRotation: (id, axis, value) =>
+    set((state) => ({
+      personnages: {
+        ...state.personnages,
+        [id]: {
+          ...state.personnages[id],
+          rotation: updateVector(state.personnages[id].rotation, axis, value),
+        },
+      },
+    })),
+  setScale: (id, axis, value) =>
+    set((state) => ({
+      personnages: {
+        ...state.personnages,
+        [id]: {
+          ...state.personnages[id],
+          scale: updateVector(state.personnages[id].scale, axis, value),
+        },
+      },
+    })),
+}));

src/managers/stores/useRepairMissionAnchorStore.ts

@@ -0,0 +1,15 @@
+import { create } from "zustand";
+import type { RepairMissionId } from "@/types/gameplay/repairMission";
+import type { Vector3Tuple } from "@/types/three/three";
+
+interface RepairMissionAnchorStore {
+  anchors: Partial<Record<RepairMissionId, Vector3Tuple>>;
+  setAnchors: (anchors: Partial<Record<RepairMissionId, Vector3Tuple>>) => void;
+}
+
+export const useRepairMissionAnchorStore = create<RepairMissionAnchorStore>(
+  (set) => ({
+    anchors: {},
+    setAnchors: (anchors) => set({ anchors }),
+  }),
+);

src/pages/docs/animation/page.tsx

@@ -5,7 +5,6 @@ export function DocsAnimationPage(): React.JSX.Element {
   return (
     <DocsDocument
       content={animation}
-      frContent={animation}
       meta="15"
       title="Animation & 3D Model System"
     />

src/pages/docs/architecture/page.tsx

@@ -5,7 +5,6 @@ export function DocsArchitecturePage(): React.JSX.Element {
   return (
     <DocsDocument
       content={architecture}
-      frContent={architecture}
       meta="02"
       title="Current Architecture"
     />

src/pages/docs/audio/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsAudioPage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={audio}
-      frContent={audio}
-      meta="08"
-      title="Audio Technical Notes"
-    />
+    <DocsDocument content={audio} meta="08" title="Audio Technical Notes" />
   );
 }

src/pages/docs/code-review/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsCodeReviewPage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={codeReview}
-      frContent={codeReview}
-      meta="16"
-      title="Code Review Prep"
-    />
+    <DocsDocument content={codeReview} meta="16" title="Code Review Prep" />
   );
 }

src/pages/docs/editor/page.tsx

@@ -2,12 +2,5 @@ import editor from "../../../../docs/user/editor.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsEditorPage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={editor}
-      frContent={editor}
-      meta="14"
-      title="Editor User Guide"
-    />
-  );
+  return <DocsDocument content={editor} meta="14" title="Editor User Guide" />;
 }

src/pages/docs/features/page.tsx

@@ -2,12 +2,5 @@ import features from "../../../../docs/user/features.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsFeaturesPage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={features}
-      frContent={features}
-      meta="12"
-      title="Features"
-    />
-  );
+  return <DocsDocument content={features} meta="12" title="Features" />;
 }

src/pages/docs/hand-tracking/page.tsx

@@ -5,7 +5,6 @@ export function DocsHandTrackingPage(): React.JSX.Element {
   return (
     <DocsDocument
       content={handTracking}
-      frContent={handTracking}
       meta="09"
       title="Hand Tracking Technical Notes"
     />

src/pages/docs/interaction/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsInteractionPage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={interaction}
-      frContent={interaction}
-      meta="05"
-      title="Interaction System"
-    />
+    <DocsDocument content={interaction} meta="05" title="Interaction System" />
   );
 }

src/pages/docs/main-feature/page.tsx

@@ -2,12 +2,5 @@ import mainFeature from "../../../../docs/user/main-feature.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsMainFeaturePage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={mainFeature}
-      frContent={mainFeature}
-      meta="13"
-      title="Main Feature"
-    />
-  );
+  return <DocsDocument content={mainFeature} meta="13" title="Main Feature" />;
 }

src/pages/docs/map-performance/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsMapPerformancePage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={mapPerformance}
-      frContent={mapPerformance}
-      meta="12"
-      title="Map Performance"
-    />
+    <DocsDocument content={mapPerformance} meta="12" title="Map Performance" />
   );
 }

src/pages/docs/page.tsx

@@ -2,12 +2,5 @@ import readme from "../../../README.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsReadmePage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={readme}
-      frContent={readme}
-      meta="01"
-      title="README"
-    />
-  );
+  return <DocsDocument content={readme} meta="01" title="README" />;
 }

src/pages/docs/repair-game/page.tsx

@@ -2,12 +2,5 @@ import repairGame from "../../../../docs/technical/repair-game.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsRepairGamePage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={repairGame}
-      frContent={repairGame}
-      meta="04"
-      title="Repair Game"
-    />
-  );
+  return <DocsDocument content={repairGame} meta="04" title="Repair Game" />;
 }

src/pages/docs/scene-runtime/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsSceneRuntimePage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={sceneRuntime}
-      frContent={sceneRuntime}
-      meta="03"
-      title="Scene Runtime"
-    />
+    <DocsDocument content={sceneRuntime} meta="03" title="Scene Runtime" />
   );
 }

src/pages/docs/target-architecture/page.tsx

@@ -5,7 +5,6 @@ export function DocsTargetArchitecturePage(): React.JSX.Element {
   return (
     <DocsDocument
       content={targetArchitecture}
-      frContent={targetArchitecture}
       meta="06"
       title="Target Architecture"
     />

src/pages/docs/technical-editor/page.tsx

@@ -5,7 +5,6 @@ export function DocsTechnicalEditorPage(): React.JSX.Element {
   return (
     <DocsDocument
       content={technicalEditor}
-      frContent={technicalEditor}
       meta="07"
       title="Editor Technical Notes"
     />

src/pages/docs/three-debugging/page.tsx

@@ -3,11 +3,6 @@ import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsThreeDebuggingPage(): React.JSX.Element {
   return (
-    <DocsDocument
-      content={threeDebugging}
-      frContent={threeDebugging}
-      meta="11"
-      title="Three Debugging"
-    />
+    <DocsDocument content={threeDebugging} meta="11" title="Three Debugging" />
   );
 }

src/pages/docs/zustand/page.tsx

@@ -2,12 +2,5 @@ import zustand from "../../../../docs/technical/zustand.md?raw";
 import { DocsDocument } from "@/components/docs/DocsDocument";
 
 export function DocsZustandPage(): React.JSX.Element {
-  return (
-    <DocsDocument
-      content={zustand}
-      frContent={zustand}
-      meta="10"
-      title="Zustand Stores"
-    />
-  );
+  return <DocsDocument content={zustand} meta="10" title="Zustand Stores" />;
 }

src/pages/editor/page.tsx

@@ -6,6 +6,7 @@ import { EditorScene } from "@/components/editor/scene/EditorScene";
 import type { EditorCinematicPreviewRequest } from "@/components/editor/scene/EditorScene";
 import { SceneLoadingOverlay } from "@/components/ui/SceneLoadingOverlay";
 import { Subtitles } from "@/components/ui/Subtitles";
+import { INITIAL_SCENE_LOADING_STATE } from "@/data/world/sceneLoadingConfig";
 import { useEditorHistory } from "@/hooks/editor/useEditorHistory";
 import type { CinematicDefinition } from "@/types/cinematics/cinematics";
 import { useEditorSceneData } from "@/hooks/editor/useEditorSceneData";
@@ -16,7 +17,6 @@ import type {
   TransformMode,
 } from "@/types/editor/editor";
 import {
-  INITIAL_SCENE_LOADING_STATE,
   type SceneLoadingChangeHandler,
   type SceneLoadingState,
 } from "@/types/world/sceneLoading";
@@ -323,6 +323,7 @@ export function EditorPage(): React.JSX.Element {
   const [newNodeName, setNewNodeName] = useState(DEFAULT_NEW_NODE_NAME);
   const [lockTerrainSelection, setLockTerrainSelection] = useState(true);
   const [resetCameraRequest, setResetCameraRequest] = useState(0);
+  const [snapAllToTerrainRequest, setSnapAllToTerrainRequest] = useState(0);
   const [focusSelectedCameraRequest, setFocusSelectedCameraRequest] =
     useState(0);
   const [cameraViewMode, setCameraViewMode] = useState<"home" | "object">(
@@ -372,9 +373,14 @@ export function EditorPage(): React.JSX.Element {
   const handleSelectNode = useCallback((index: number | null) => {
     setSelectedNodeIndex(index);
     setSelectedNodeIndexes(index === null ? [] : [index]);
+
     if (index !== null) {
       setCameraViewMode("object");
+      return;
     }
+
+    setCameraViewMode("home");
+    setResetCameraRequest((request) => request + 1);
   }, []);
 
   const handleToggleNodeSelection = useCallback((index: number) => {
@@ -387,6 +393,9 @@ export function EditorPage(): React.JSX.Element {
       setSelectedNodeIndex(nextIndexes.at(-1) ?? null);
       if (nextIndexes.length > 0) {
         setCameraViewMode("object");
+      } else {
+        setCameraViewMode("home");
+        setResetCameraRequest((request) => request + 1);
       }
 
       return nextIndexes;
@@ -396,6 +405,8 @@ export function EditorPage(): React.JSX.Element {
   const handleClearSelection = useCallback(() => {
     setSelectedNodeIndex(null);
     setSelectedNodeIndexes([]);
+    setCameraViewMode("home");
+    setResetCameraRequest((request) => request + 1);
   }, []);
 
   const handleSelectionLockToggle = useCallback(() => {
@@ -406,6 +417,25 @@ export function EditorPage(): React.JSX.Element {
     setSnapToTerrain((enabled) => !enabled);
   }, []);
 
+  const handleSnapAllToTerrainRequest = useCallback(() => {
+    setSnapAllToTerrainRequest((request) => request + 1);
+  }, []);
+
+  const handleSnapAllToTerrain = useCallback(
+    (mapNodes: MapNode[]) => {
+      setSceneData((prev) => {
+        if (!prev) return null;
+
+        const nextSceneData = { ...prev, mapNodes };
+        if (!prev.mapTree) return nextSceneData;
+
+        const mapTree = mergeFlatNodeTransformsIntoTree(nextSceneData);
+        return updateSceneDataTree(nextSceneData, mapTree);
+      });
+    },
+    [setSceneData],
+  );
+
   const handleNewNodeNameChange = useCallback((value: string) => {
     setNewNodeName(value);
   }, []);
@@ -710,6 +740,8 @@ export function EditorPage(): React.JSX.Element {
             onTransformStart={handleTransformStart}
             onTransformEnd={handleTransformEnd}
             onNodeTransform={handleNodeTransform}
+            snapAllToTerrainRequest={snapAllToTerrainRequest}
+            onSnapAllToTerrain={handleSnapAllToTerrain}
             onUndo={handleUndo}
             onRedo={handleRedo}
             resetCameraRequest={resetCameraRequest}
@@ -748,6 +780,7 @@ export function EditorPage(): React.JSX.Element {
           onClearSelection={handleClearSelection}
           snapToTerrain={snapToTerrain}
           onSnapToTerrainToggle={handleSnapToTerrainToggle}
+          onSnapAllToTerrain={handleSnapAllToTerrainRequest}
           newNodeName={newNodeName}
           onNewNodeNameChange={handleNewNodeNameChange}
           onAddNode={handleAddNode}

src/pages/page.tsx

@@ -6,12 +6,10 @@ import { DialogMessage } from "@/components/ui/DialogMessage";
 import { GameUI } from "@/components/ui/GameUI";
 import { BienvenueDisplay, IntroUI } from "@/components/ui/IntroUI";
 import { SceneLoadingOverlay } from "@/components/ui/SceneLoadingOverlay";
+import { INITIAL_SCENE_LOADING_STATE } from "@/data/world/sceneLoadingConfig";
 import { useGameStore } from "@/managers/stores/useGameStore";
 import { HandTrackingProvider } from "@/providers/gameplay/HandTrackingProvider";
-import {
-  INITIAL_SCENE_LOADING_STATE,
-  type SceneLoadingState,
-} from "@/types/world/sceneLoading";
+import type { SceneLoadingState } from "@/types/world/sceneLoading";
 import { logger } from "@/utils/core/Logger";
 import { World } from "@/world/World";
 

src/providers/gameplay/HandTrackingProvider.tsx

@@ -28,10 +28,10 @@ export function HandTrackingProvider({
     switch (state.mainState) {
       case "ebike":
         return REPAIR_HAND_TRACKING_STEPS.has(state.ebike.currentStep);
-      case "pylone":
-        return REPAIR_HAND_TRACKING_STEPS.has(state.pylone.currentStep);
-      case "ferme":
-        return REPAIR_HAND_TRACKING_STEPS.has(state.ferme.currentStep);
+      case "pylon":
+        return REPAIR_HAND_TRACKING_STEPS.has(state.pylon.currentStep);
+      case "farm":
+        return REPAIR_HAND_TRACKING_STEPS.has(state.farm.currentStep);
       case "intro":
       case "outro":
         return false;

src/types/game.ts

@@ -12,40 +12,7 @@ export type GameStep =
   | "manipulation"
   | "outOfFabrik";
 
-export const GAME_STEPS: readonly GameStep[] = [
-  "intro",
-  "start-intro",
-  "naming",
-  "bienvenue",
-  "star-move",
-  "mission2",
-  "searching",
-  "helped",
-  "manipulation",
-  "outOfFabrik",
-] as const;
-
-const GAME_STEP_VALUES: ReadonlySet<string> = new Set(GAME_STEPS);
-
-export type MainGameState = "intro" | "ebike" | "pylone" | "ferme" | "outro";
-
-export const MAIN_GAME_STATES: readonly MainGameState[] = [
-  "intro",
-  "ebike",
-  "pylone",
-  "ferme",
-  "outro",
-] as const;
-
-const MAIN_GAME_STATE_VALUES: ReadonlySet<string> = new Set(MAIN_GAME_STATES);
-
-export function isGameStep(value: unknown): value is GameStep {
-  return typeof value === "string" && GAME_STEP_VALUES.has(value);
-}
-
-export function isMainGameState(value: unknown): value is MainGameState {
-  return typeof value === "string" && MAIN_GAME_STATE_VALUES.has(value);
-}
+export type MainGameState = "intro" | "ebike" | "pylon" | "farm" | "outro";
 
 export interface Zone {
   id: string;

src/types/gameplay/repairMission.ts

@@ -4,7 +4,13 @@ import type {
   Vector3Tuple,
 } from "@/types/three/three";
 
-export type RepairMissionId = "ebike" | "pylone" | "ferme";
+export type RepairMissionId = "ebike" | "pylon" | "farm";
+
+export interface RepairMissionTriggerConfig {
+  mission: RepairMissionId;
+  label: string;
+  radius: number;
+}
 
 export interface RepairMissionCaseConfig {
   position: Vector3Tuple;
@@ -53,68 +59,3 @@ export type MissionStep =
   | "repairing"
   | "reassembling"
   | "done";
-
-const REPAIR_MISSION_IDS = ["ebike", "pylone", "ferme"] as const;
-const REPAIR_MISSION_ID_VALUES: ReadonlySet<string> = new Set(
-  REPAIR_MISSION_IDS,
-);
-
-export const MISSION_STEPS = [
-  "locked",
-  "waiting",
-  "inspected",
-  "fragmented",
-  "scanning",
-  "repairing",
-  "reassembling",
-  "done",
-] as const satisfies readonly MissionStep[];
-const MISSION_STEP_VALUES: ReadonlySet<string> = new Set(MISSION_STEPS);
-
-export function isRepairMissionId(value: string): value is RepairMissionId {
-  return REPAIR_MISSION_ID_VALUES.has(value);
-}
-
-export function isMissionStep(value: string): value is MissionStep {
-  return MISSION_STEP_VALUES.has(value);
-}
-
-export function getNextMissionStep(step: MissionStep): MissionStep {
-  switch (step) {
-    case "locked":
-      return "waiting";
-    case "waiting":
-      return "inspected";
-    case "inspected":
-      return "fragmented";
-    case "fragmented":
-      return "scanning";
-    case "scanning":
-      return "repairing";
-    case "repairing":
-      return "reassembling";
-    case "reassembling":
-    case "done":
-      return "done";
-  }
-}
-
-export function getPreviousMissionStep(step: MissionStep): MissionStep {
-  switch (step) {
-    case "locked":
-    case "waiting":
-      return "locked";
-    case "inspected":
-      return "waiting";
-    case "fragmented":
-      return "inspected";
-    case "scanning":
-      return "fragmented";
-    case "repairing":
-      return "scanning";
-    case "reassembling":
-      return "repairing";
-    case "done":
-      return "reassembling";
-  }
-}

src/types/map/mapScene.ts

@@ -9,6 +9,15 @@ export interface MapNode {
   sourcePath?: number[];
 }
 
+export interface MapNodeInstanceTransform {
+  position: Vector3Tuple;
+  rotation: Vector3Tuple;
+  scale: Vector3Tuple;
+}
+
+export type MapAssetInstance = MapNodeInstanceTransform;
+export type VegetationInstance = MapNodeInstanceTransform;
+
 export interface HierarchicalMapNode extends MapNode {
   role?: "group";
   children?: HierarchicalMapNode[];

src/types/world/sceneLoading.ts

@@ -7,9 +7,3 @@ export interface SceneLoadingState {
 }
 
 export type SceneLoadingChangeHandler = (state: SceneLoadingState) => void;
-
-export const INITIAL_SCENE_LOADING_STATE: SceneLoadingState = {
-  currentStep: "Initialisation du jeu",
-  progress: 0,
-  status: "loading",
-};

src/types/world/terrainSurface.ts

@@ -1,5 +1,3 @@
-import type * as THREE from "three";
-
 export type TerrainSurfaceKind =
   | "grass"
   | "path"
@@ -10,18 +8,6 @@ export type TerrainSurfaceKind =
 
 export type TerrainSurfaceRgb = readonly [number, number, number];
 
-export interface TerrainSurfaceUv {
-  u: number;
-  v: number;
-}
-
-export interface TerrainSurfaceProjectionConfig {
-  flipX?: boolean;
-  flipZ?: boolean;
-  offsetX?: number;
-  offsetZ?: number;
-}
-
 export interface TerrainSurfaceBounds {
   minX: number;
   maxX: number;
@@ -37,15 +23,3 @@ export interface TerrainSurfaceColorConfig {
   modelPath?: string;
   tileSize?: number;
 }
-
-export interface TerrainSurfaceSample {
-  rgb: TerrainSurfaceRgb;
-  key: string | null;
-  config: TerrainSurfaceColorConfig | null;
-}
-
-export interface TerrainSurfaceData {
-  bounds: TerrainSurfaceBounds;
-  imageData: ImageData;
-  raycastTarget: THREE.Object3D;
-}

src/utils/debug/Debug.ts

@@ -24,6 +24,7 @@ const DEBUG_FOLDER_ORDER = [
   "Interaction",
   "Hand Tracking",
   "Map",
+  "Personnages",
 ] as const;
 
 function isRecord(value: unknown): value is Record<string, unknown> {