fix: a pb with octree

docs/technical/architecture.md

@@ -20,7 +20,7 @@ This document describes the code that exists today in the repository.
 - `src/world/GameStageContent.tsx` is wrapped in Rapier `Physics` in the production game scene so stage gameplay objects can use physics without moving the map or player to Rapier. It now mounts reusable `RepairGame` instances for `bike`, `pylone`, and `ferme` mission states.
 - `src/world/debug/TestMap.tsx` provides a debug-oriented interaction and physics map with the existing grab/trigger/model-preview objects plus separate `Bike`, `Pylone`, and `Farm` repair playground zones.
 - `src/world/player/Player.tsx` mounts the camera and controller.
-- `src/world/player/PlayerController.tsx` owns pointer lock movement, jump handling, and interaction input.
+- `src/world/player/PlayerController.tsx` owns pointer lock movement, jump handling, repair-step movement locking, and interaction input.
 
 ## Physics Boundaries
 

docs/technical/hand-tracking.md

@@ -37,7 +37,7 @@ The production repair activation conditions are:
 
 This keeps the webcam off during `waiting`, `fragmented`, and `scanning`, then enables hand input only when the repair flow is expected to use hands.
 
-In the current production repair flow, `inspected` uses a two-fists hold gesture to advance to `fragmented`. The hold must last one second and is independent from local object interaction distance once the mission is in the correct state.
+In the current production repair flow, `inspected` uses a two-fists hold gesture to advance to `fragmented`. The hold must last one second and is independent from local object interaction distance once the mission is in the correct state. Keyboard input for the same transition is handled separately by the repair case trigger, so pressing `E` requires the case to be focused through the shared interaction system.
 
 ## Backend
 

docs/technical/zustand.md

@@ -170,6 +170,7 @@ Current overlays:
 - `GameStateDebugPanel`: compact debug UI for viewing and switching main/sub states, stepping backward or forward, and resetting the store
 - `Crosshair`: player aiming helper
 - `InteractPrompt`: interaction prompt
+- `RepairMovementLockIndicator`: player-facing indicator shown while repair steps temporarily disable movement
 
 `src/pages/page.tsx` should stay thin and mount only the canvas and `GameUI`.
 

docs/user/features.md

@@ -18,6 +18,7 @@ This document lists features that are implemented in the current codebase.
 - Pointer lock mouse look
 - Movement with `ZQSD`
 - Jumping
+- Movement lock during active repair steps, with an on-screen indicator while keeping trigger interactions available
 - Octree-based collision against dedicated map collision nodes, currently scoped to `terrain`
 
 ## Interactions
@@ -33,7 +34,7 @@ This document lists features that are implemented in the current codebase.
 - Reusable production `RepairGame` mounted for `bike`, `pylone`, and `ferme` mission states
 - Debug physics playground mounts the same reusable `RepairGame` in `Bike`, `Pylone`, and `Farm` zones so each state can be tuned with isolated positioning before moving placement into the production map
 - Repair mission config shared through `src/data/gameplay/repairMissions.ts`, including per-mission broken nodes, placeholder targets, scan timing, and reassembly timing
-- Repair-game flow supports `waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done -> next mission` with `.webm` prompts, repair case spawn/opening/exit, focused repair-case view, case placeholder traversal, snap-to-placeholder placement, broken-part deposit, `E`, two-fists hold input, exploded and inverse reassembly transitions, completion particles, per-part scan visuals, persistent red broken-part markers, centered broken-part UI videos, multiple grabbable replacement choices, correct-part install validation, and mission completion
+- Repair-game flow supports `waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done -> next mission` with `.webm` prompts, repair case spawn/opening/exit, focused repair-case view, movement lock indicator during active repair, repair-case trigger interaction, case placeholder traversal, snap-to-placeholder placement, broken-part deposit feedback, `E`, two-fists hold input, exploded and inverse reassembly transitions, completion particles, per-part scan visuals, persistent red broken-part markers, centered broken-part UI videos, multiple grabbable replacement choices, correct-part install validation feedback, and mission completion
 
 ## Audio
 
@@ -45,6 +46,7 @@ This document lists features that are implemented in the current codebase.
 - `?debug` query param enables the debug panel
 - `lil-gui` controls for camera mode, scene mode, `R3F Perf`, `Debug Overlay`, and interaction tuning
 - Compact debug overlay for game state controls and hand tracking status
+- Debug game-state mission switching unlocks locked repair missions at `waiting` for faster testing
 - Debug scene helpers
 - Free debug camera
 - `r3f-perf` overlay

docs/user/main-feature.md

@@ -12,15 +12,15 @@ The current user flow is:
 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`.
-5. The repair case appears near the mission object and can float when the player approaches it.
-6. Press `E` or hold both fists closed for one second to move from `inspected` to `fragmented`.
+5. The repair case appears near the mission object, the player movement controls are locked, and the case can float when the player approaches it.
+6. Aim at the repair case and press `E`, or hold both fists closed for one second, to move from `inspected` to `fragmented`.
 7. The mission object uses an exploded-model transition, then moves to `scanning`.
 8. The scan visual moves across the fragmented model one part at a time and keeps a red marker plus the `cassé.webm` prompt centered on any configured broken part once it has been found.
 9. In `repairing`, the case opens in a larger focused view and several grabbable replacement parts appear on the case placeholders.
 10. Move the correct replacement part close to a placeholder. When released near a placeholder, it snaps into place with a short animation.
 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`.
+13. The exploded object animates back into its assembled form with completion particles, then moves to `done` and restores player movement controls.
 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`.
 
 ## Why It Matters
@@ -31,11 +31,11 @@ This feature validates the repair loop before a full mission system exists. It t
 
 In `waiting`, the active mission renders its repair object and the `interagir.webm` prompt in the game scene. The interaction uses the shared focus/raycast interaction system, so the player still gets the normal `E` prompt.
 
-When the player inspects the object, `RepairGame` writes `inspected` through the generic mission store action. The repair case then appears from the mission config with a small pop animation. When the player is close enough, the existing case model floats upward and rotates gently to signal interactivity.
+When the player inspects the object, `RepairGame` writes `inspected` through the generic mission store action. The repair case then appears from the mission config with a small pop animation, player movement is locked while the repair sequence is active, and a small HTML indicator confirms that movement is temporarily unavailable. When the player is close enough, the existing case model floats upward and rotates gently to signal interactivity.
 
-In `inspected`, `RepairGame` can also move to `fragmented`. The player can use the interaction key or hold both fists closed for one second. The hand-tracking path is state-based, so it does not depend on being inside a local object interaction radius.
+In `inspected`, `RepairGame` can also move to `fragmented`. Keyboard input goes through the shared focus/raycast interaction system on the repair case, so the player must be close enough and aim at the case before pressing `E`. The hand-tracking path still uses a two-fists hold gesture and is state-based, so it does not depend on being inside a local object interaction radius.
 
-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 can match a specific `nodeName` when mission data provides one, otherwise it falls back to the first scanned parts as placeholder broken parts. 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 placeholder positions, and releasing a part near a placeholder 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 placeholder before the final install target validates. If `brokenParts[].placeholderName` is configured, that broken part snaps only to the matching placeholder; otherwise it can use any available placeholder. If the current case asset has no placeholder nodes, the flow keeps using fallback focus positions. 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 that plays the case exit animation before advancing the global mission progression.
+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 can match a specific `nodeName` when mission data provides one, otherwise it falls back to the first scanned parts as placeholder broken parts. 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 placeholder positions, and releasing a part near a placeholder 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 placeholder before the final install target validates. If `brokenParts[].placeholderName` is configured, that broken part snaps only to the matching placeholder; otherwise it can use any available placeholder. If the current case asset has no placeholder nodes, the flow keeps using fallback focus positions. 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. Player movement stays locked through `inspected`, `fragmented`, `scanning`, `repairing`, and `reassembling`, while trigger interactions remain available. In `reassembling`, the exploded model animates back into its assembled position with green completion particles before the flow moves to `done`. In `done`, player movement is available again and 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.
 
@@ -54,8 +54,10 @@ 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/hooks/gameplay/useRepairFragmentationInput.ts` handles the `inspected -> fragmented` keyboard and hand-tracking input.
+- `src/components/ui/RepairMovementLockIndicator.tsx` renders the HTML indicator shown while repair movement is locked.
+- `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.
 - `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.
@@ -86,7 +88,7 @@ Debug URL for state switching and inspection:
 http://localhost:5173/?debug
 ```
 
-The debug physics scene keeps the existing grab, trigger, and animated model tests, and also exposes separate `Bike`, `Pylone`, and `Farm` repair playground zones. Use the debug game-state panel to switch `mainState`; the matching repair zone mounts the same reusable `RepairGame` flow with that mission's model, broken parts, replacement parts, prompts, and timings.
+The debug physics scene keeps the existing grab, trigger, and animated model tests, and also exposes separate `Bike`, `Pylone`, and `Farm` repair playground zones. Use the debug game-state panel to switch `mainState`; selecting a locked repair mission in that panel opens it at `waiting`, and the matching repair zone mounts the same reusable `RepairGame` flow with that mission's model, broken parts, replacement parts, prompts, and timings.
 
 ## Related Hand Tracking
 
@@ -104,5 +106,5 @@ python -m backend.main
 - The reusable production `RepairGame` currently covers `waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done -> next mission`.
 - Mission progression is wired through Zustand using `completeMission` at the end of each repair.
 - There is no central `GameManager` in this branch.
-- Hand tracking is available for the two-fists input and grabbable replacement parts; final installation still uses the shared `E` trigger path.
+- Hand tracking is available for the two-fists input and grabbable repair parts; case interaction and final installation still use the shared `E` trigger path.
 - The repair-game content is configured statically in `src/data/gameplay/`.

src/components/three/gameplay/RepairCompletionStep.tsx

@@ -1,8 +1,10 @@
-import { useState } from "react";
+import { useEffect, useState } from "react";
 import { RepairObjectModel } from "@/components/three/gameplay/RepairObjectModel";
 import { RepairPromptVideo } from "@/components/three/gameplay/RepairPromptVideo";
 import { RepairMissionCase } from "@/components/three/gameplay/RepairMissionCase";
 import { TriggerObject } from "@/components/three/interaction/TriggerObject";
+import { REPAIR_CASE_ANIMATION_DURATION } from "@/data/gameplay/repairCaseConfig";
+import { REPAIR_INTERACTION_RADIUS } from "@/data/gameplay/repairGameConfig";
 import type { RepairMissionConfig } from "@/data/gameplay/repairMissions";
 
 interface RepairCompletionStepProps {
@@ -14,28 +16,43 @@ export function RepairCompletionStep({
   config,
   onComplete,
 }: RepairCompletionStepProps): React.JSX.Element {
-  const [isCompleting, setIsCompleting] = useState(false);
+  const [isClosingCase, setIsClosingCase] = useState(false);
+  const [isExitingCase, setIsExitingCase] = useState(false);
+
+  useEffect(() => {
+    if (!isClosingCase) return undefined;
+
+    const timeoutId = window.setTimeout(() => {
+      setIsExitingCase(true);
+    }, REPAIR_CASE_ANIMATION_DURATION * 1000);
+
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [isClosingCase]);
 
   return (
     <group>
       <RepairMissionCase
         config={config}
-        exiting={isCompleting}
+        exiting={isExitingCase}
+        open={!isClosingCase}
         onExitComplete={onComplete}
       />
 
       <RepairObjectModel
         label={config.label}
         modelPath={config.modelPath}
-        scale={1}
+        scale={config.modelScale ?? 1}
       />
 
-      {!isCompleting ? (
+      {!isClosingCase ? (
         <TriggerObject
           position={[0, 1.1, 0]}
           colliders="ball"
           label={`Valider ${config.label}`}
-          onTrigger={() => setIsCompleting(true)}
+          radius={REPAIR_INTERACTION_RADIUS}
+          onTrigger={() => setIsClosingCase(true)}
         >
           <mesh>
             <torusGeometry args={[1.35, 0.045, 12, 96]} />
@@ -48,7 +65,7 @@ export function RepairCompletionStep({
         </TriggerObject>
       ) : null}
 
-      {!isCompleting ? (
+      {!isClosingCase ? (
         <RepairPromptVideo src={config.stageUiPath} position={[0, 2.55, 0]} />
       ) : null}
     </group>

src/components/three/gameplay/RepairGame.tsx

@@ -19,7 +19,10 @@ import {
 } from "@/data/gameplay/repairMissions";
 import { useRepairFragmentationInput } from "@/hooks/gameplay/useRepairFragmentationInput";
 import { useRepairMissionStep } from "@/hooks/gameplay/useRepairMissionStep";
-import type { RepairMissionId } from "@/types/gameplay/repairMission";
+import type {
+  MissionStep,
+  RepairMissionId,
+} from "@/types/gameplay/repairMission";
 import { useGameStore } from "@/managers/stores/useGameStore";
 import type { ModelTransformProps, Vector3Tuple } from "@/types/three/three";
 import { toVector3Scale } from "@/utils/three/scale";
@@ -75,6 +78,19 @@ export function RepairGame({
     onFragment: () => setMissionStep(mission, "fragmented"),
   });
 
+  useEffect(() => {
+    if (mainState === mission && shouldKeepRepairRuntimeState(step)) return;
+
+    const timeoutId = window.setTimeout(() => {
+      setCasePlaceholders([]);
+      setScannedBrokenParts([]);
+    }, 0);
+
+    return () => {
+      window.clearTimeout(timeoutId);
+    };
+  }, [mainState, mission, step]);
+
   useEffect(() => {
     if (mainState !== mission) return undefined;
 
@@ -106,7 +122,11 @@ export function RepairGame({
           />
         ) : null}
         {step === "fragmented" ? (
-          <ExplodableModel modelPath={config.modelPath} split />
+          <ExplodableModel
+            modelPath={config.modelPath}
+            scale={config.modelScale ?? 1}
+            split
+          />
         ) : null}
         {step === "scanning" ? (
           <RepairScanSequence
@@ -156,6 +176,10 @@ export function RepairGame({
   );
 }
 
+function shouldKeepRepairRuntimeState(step: MissionStep): boolean {
+  return step === "repairing" || step === "reassembling" || step === "done";
+}
+
 function getRepairMissionModelPaths(config: RepairMissionConfig): string[] {
   return [
     ...new Set([

src/components/three/gameplay/RepairInspectionObject.tsx

@@ -1,6 +1,7 @@
 import { InteractableObject } from "@/components/three/interaction/InteractableObject";
 import { RepairObjectModel } from "@/components/three/gameplay/RepairObjectModel";
 import { RepairPromptVideo } from "@/components/three/gameplay/RepairPromptVideo";
+import { REPAIR_INTERACTION_RADIUS } from "@/data/gameplay/repairGameConfig";
 import type { RepairMissionConfig } from "@/data/gameplay/repairMissions";
 import type { Vector3Tuple } from "@/types/three/three";
 
@@ -20,14 +21,15 @@ export function RepairInspectionObject({
       kind="trigger"
       label={`Inspecter ${config.label}`}
       position={worldPosition}
+      radius={REPAIR_INTERACTION_RADIUS}
       onPress={onInspect}
     >
       <RepairObjectModel
         label={config.label}
         modelPath={config.modelPath}
-        scale={0.9}
+        scale={config.modelScale ?? 0.9}
       />
-      <RepairPromptVideo src={config.interactUiPath} />
+      <RepairPromptVideo src={config.stageUiPath} />
     </InteractableObject>
   );
 }

src/components/three/gameplay/RepairMissionCase.tsx

@@ -9,6 +9,7 @@ import {
   REPAIR_CASE_FOCUS_SCALE,
   REPAIR_CASE_MODEL_PATH,
 } from "@/data/gameplay/repairCaseConfig";
+import { REPAIR_INTERACTION_RADIUS } from "@/data/gameplay/repairGameConfig";
 import type { RepairMissionConfig } from "@/data/gameplay/repairMissions";
 import type { Vector3Tuple } from "@/types/three/three";
 
@@ -48,6 +49,7 @@ export function RepairMissionCase({
           position={casePosition}
           colliders="ball"
           label={`Ouvrir ${config.label}`}
+          radius={REPAIR_INTERACTION_RADIUS}
           onTrigger={onInteract}
         >
           <RepairCaseModel

src/components/three/gameplay/RepairReassemblyStep.tsx

@@ -35,6 +35,7 @@ export function RepairReassemblyStep({
     <group>
       <ExplodableModel
         modelPath={config.modelPath}
+        scale={config.modelScale ?? 1}
         split={split}
         splitDistance={1.2}
       />

src/components/three/gameplay/RepairRepairingStep.tsx

@@ -11,6 +11,7 @@ import {
   REPAIR_CASE_PLACEHOLDER_SNAP_DURATION,
   REPAIR_CASE_PLACEHOLDER_SNAP_RADIUS,
 } from "@/data/gameplay/repairCaseConfig";
+import { REPAIR_INTERACTION_RADIUS } from "@/data/gameplay/repairGameConfig";
 import type {
   RepairMissionConfig,
   RepairMissionPartConfig,
@@ -299,6 +300,7 @@ function RepairInstallTarget({
       position={INSTALL_TARGET_POSITION}
       colliders="ball"
       label={label}
+      radius={REPAIR_INTERACTION_RADIUS}
       onTrigger={() => {
         if (!isReadyToInstall) {
           onBlocked();

src/components/three/gameplay/RepairScanSequence.tsx

@@ -60,6 +60,7 @@ export function RepairScanSequence({
     <group>
       <ExplodableModel
         modelPath={config.modelPath}
+        scale={config.modelScale ?? 1}
         split
         onPartsReady={setParts}
       />

src/components/three/interaction/InteractableObject.tsx

@@ -19,6 +19,7 @@ import type { Vector3Tuple } from "@/types/three/three";
 interface InteractableObjectBaseProps {
   label: string;
   position: Vector3Tuple;
+  radius?: number;
   bodyRef?: RefObject<RapierRigidBody | null>;
   onPress: () => void;
   children: React.ReactNode;
@@ -64,7 +65,15 @@ function createInteractableHandle(
 export function InteractableObject(
   props: InteractableObjectProps,
 ): React.JSX.Element {
-  const { kind, label, position, bodyRef, onPress, children } = props;
+  const {
+    kind,
+    label,
+    position,
+    radius = INTERACTION_RADIUS,
+    bodyRef,
+    onPress,
+    children,
+  } = props;
   const onRelease = props.kind === "grab" ? props.onRelease : null;
   const camera = useThree((state) => state.camera);
   const groupRef = useRef<THREE.Group>(null);
@@ -156,7 +165,7 @@ export function InteractableObject(
 
     camera.getWorldPosition(_cameraPos);
     const dist = _cameraPos.distanceTo(_objectPos);
-    const isNearby = dist <= INTERACTION_RADIUS;
+    const isNearby = dist <= radius;
 
     manager.setNearby(handle.current, isNearby);
 
@@ -169,7 +178,7 @@ export function InteractableObject(
 
     camera.getWorldDirection(_cameraDir);
     _raycaster.set(_cameraPos, _cameraDir);
-    _raycaster.far = INTERACTION_RADIUS;
+    _raycaster.far = radius;
 
     const hits = group ? _raycaster.intersectObject(group, true) : [];
     const validHit = hits.find((h) => h.object !== debugSphereRef.current);
@@ -187,7 +196,7 @@ export function InteractableObject(
       <mesh ref={debugSphereRef} visible={false}>
         <sphereGeometry
           args={[
-            INTERACTION_RADIUS,
+            radius,
             INTERACTION_DEBUG_SPHERE_SEGMENTS,
             INTERACTION_DEBUG_SPHERE_SEGMENTS,
           ]}

src/components/three/interaction/TriggerObject.tsx

@@ -4,6 +4,7 @@ import type { RapierRigidBody } from "@react-three/rapier";
 import { InteractableObject } from "@/components/three/interaction/InteractableObject";
 import { useClonedObject } from "@/hooks/three/useClonedObject";
 import { useLoggedGLTF } from "@/hooks/three/useLoggedGLTF";
+import { INTERACTION_RADIUS } from "@/data/interaction/interactionConfig";
 import {
   TRIGGER_DEFAULT_COLLIDERS,
   TRIGGER_DEFAULT_LABEL,
@@ -23,6 +24,7 @@ interface TriggerObjectProps {
   children: React.ReactNode;
   colliders?: ColliderShape;
   label?: string;
+  radius?: number;
   soundPath?: string;
   soundVolume?: number;
   spawnModel?: string;
@@ -53,6 +55,7 @@ export function TriggerObject({
   children,
   colliders = TRIGGER_DEFAULT_COLLIDERS,
   label = TRIGGER_DEFAULT_LABEL,
+  radius = INTERACTION_RADIUS,
   soundPath,
   soundVolume = TRIGGER_DEFAULT_SOUND_VOLUME,
   spawnModel,
@@ -74,6 +77,7 @@ export function TriggerObject({
           kind="trigger"
           label={label}
           position={position}
+          radius={radius}
           bodyRef={rbRef}
           onPress={() => {
             if (soundPath) {

src/components/ui/GameUI.tsx

@@ -2,12 +2,14 @@ import { Crosshair } from "@/components/ui/Crosshair";
 import { DebugOverlayLayout } from "@/components/ui/debug/DebugOverlayLayout";
 import { HandTrackingVisualizer } from "@/components/ui/HandTrackingVisualizer";
 import { InteractPrompt } from "@/components/ui/InteractPrompt";
+import { RepairMovementLockIndicator } from "@/components/ui/RepairMovementLockIndicator";
 
 export function GameUI(): React.JSX.Element {
   return (
     <>
       <DebugOverlayLayout />
       <Crosshair />
+      <RepairMovementLockIndicator />
       <InteractPrompt />
       <HandTrackingVisualizer />
     </>

src/components/ui/RepairMovementLockIndicator.tsx

@@ -0,0 +1,20 @@
+import { useCameraMode } from "@/hooks/debug/useCameraMode";
+import { useRepairMovementLocked } from "@/hooks/gameplay/useRepairMovementLocked";
+
+export function RepairMovementLockIndicator(): React.JSX.Element | null {
+  const cameraMode = useCameraMode();
+  const movementLocked = useRepairMovementLocked();
+
+  if (cameraMode !== "player") return null;
+  if (!movementLocked) return null;
+
+  return (
+    <div className="repair-movement-lock-indicator" aria-live="polite">
+      <span
+        className="repair-movement-lock-indicator__dot"
+        aria-hidden="true"
+      />
+      <span>Déplacement verrouillé pendant la réparation</span>
+    </div>
+  );
+}

src/components/ui/debug/GameStateDebugPanel.tsx

@@ -23,6 +23,9 @@ function toPascalCase(value: string): string {
 
 export function GameStateDebugPanel(): React.JSX.Element {
   const mainState = useGameStore((state) => state.mainState);
+  const bikeStep = useGameStore((state) => state.bike.currentStep);
+  const pyloneStep = useGameStore((state) => state.pylone.currentStep);
+  const fermeStep = useGameStore((state) => state.ferme.currentStep);
   const detail = useGameStore((state) => {
     switch (state.mainState) {
       case "intro":
@@ -83,6 +86,24 @@ export function GameStateDebugPanel(): React.JSX.Element {
     }
   }
 
+  function setDebugMainState(nextMainState: MainGameState): void {
+    setMainState(nextMainState);
+
+    if (nextMainState === "bike" && bikeStep === "locked") {
+      setBikeState({ currentStep: "waiting" });
+      return;
+    }
+
+    if (nextMainState === "pylone" && pyloneStep === "locked") {
+      setPyloneState({ currentStep: "waiting" });
+      return;
+    }
+
+    if (nextMainState === "ferme" && fermeStep === "locked") {
+      setFermeState({ currentStep: "waiting" });
+    }
+  }
+
   return (
     <section
       className="game-state-debug-panel debug-overlay-section"
@@ -108,7 +129,7 @@ export function GameStateDebugPanel(): React.JSX.Element {
               aria-pressed={state === mainState}
               className={state === mainState ? "is-active" : undefined}
               type="button"
-              onClick={() => setMainState(state)}
+              onClick={() => setDebugMainState(state)}
             >
               {toPascalCase(state)}
             </button>

src/data/docs/docsTranslations.ts

@@ -101,7 +101,7 @@ Ce document décrit le code réellement présent aujourd'hui dans le dépôt.
 - \`src/world/GameStageContent.tsx\` est enveloppé dans le contexte Rapier \`Physics\` dans la scène de jeu de production afin que les objets gameplay de stage puissent utiliser la physique sans migrer la carte ou le joueur vers Rapier. Il monte maintenant des instances réutilisables de \`RepairGame\` pour les états de mission \`bike\`, \`pylone\` et \`ferme\`.
 - \`src/world/debug/TestMap.tsx\` fournit une carte orientée debug pour les interactions et la physique, avec les objets existants de grab, trigger et preview de modèle, plus des zones playground de réparation séparées \`Bike\`, \`Pylone\` et \`Farm\`.
 - \`src/world/player/Player.tsx\` monte la caméra et le contrôleur.
-- \`src/world/player/PlayerController.tsx\` gère le mouvement pointer lock, le saut et les inputs d'interaction.
+- \`src/world/player/PlayerController.tsx\` gère le mouvement pointer lock, le saut, le verrouillage de déplacement pendant les étapes repair et les inputs d'interaction.
 
 ## Frontières physiques
 
@@ -393,6 +393,7 @@ Overlays actuels :
 - \`GameStateDebugPanel\` : panneau de progression debug pour consulter/changer le main state, le sub state, avancer/reculer et reset le store
 - \`Crosshair\` : aide de visée joueur
 - \`InteractPrompt\` : prompt d'interaction
+- \`RepairMovementLockIndicator\` : indicateur joueur affiché quand les étapes repair désactivent temporairement le déplacement
 
 \`src/pages/page.tsx\` doit rester fin et monter seulement le canvas et \`GameUI\`.
 
@@ -429,6 +430,7 @@ Ce document liste les fonctionnalités présentes dans le code actuel.
 - Orientation souris avec pointer lock
 - Déplacement avec \`ZQSD\`
 - Saut
+- Verrouillage du déplacement pendant les étapes repair actives, avec indicateur à l'écran tout en gardant les interactions trigger disponibles
 - Collision basée sur une octree contre la carte chargée
 
 ## Interactions
@@ -444,7 +446,7 @@ Ce document liste les fonctionnalités présentes dans le code actuel.
 - \`RepairGame\` de production réutilisable monté pour les états de mission \`bike\`, \`pylone\` et \`ferme\`
 - Le playground physics debug monte le même \`RepairGame\` réutilisable dans des zones \`Bike\`, \`Pylone\` et \`Farm\`, afin de peaufiner chaque state avec un placement isolé avant déplacement vers la carte de production
 - Configuration de mission partagée via \`src/data/gameplay/repairMissions.ts\`, avec nodes cassés, placeholders cibles, timing de scan et timing de réassemblage propres à chaque mission
-- Flow repair-game avec \`waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done -> next mission\`, prompts \`.webm\`, apparition/ouverture/sortie de la mallette, vue focalisée de la mallette, traverse des placeholders de mallette, placement avec snap vers placeholder, dépôt des pièces cassées, touche \`E\`, hold deux poings, transition de modèle explosé, réassemblage inverse avec particules, scan visuel par pièce, marqueur rouge persistant et vidéo UI centrée sur les pièces cassées, plusieurs choix de pièces grabbables, validation de la bonne pièce et complétion de mission
+- Flow repair-game avec \`waiting -> inspected -> fragmented -> scanning -> repairing -> reassembling -> done -> next mission\`, prompts \`.webm\`, apparition/ouverture/sortie de la mallette, vue focalisée de la mallette, indicateur de verrouillage de déplacement pendant la réparation active, interaction trigger sur la mallette, traverse des placeholders de mallette, placement avec snap vers placeholder, feedback de dépôt des pièces cassées, touche \`E\`, hold deux poings, transition de modèle explosé, réassemblage inverse avec particules, scan visuel par pièce, marqueur rouge persistant et vidéo UI centrée sur les pièces cassées, plusieurs choix de pièces grabbables, feedback de validation de la bonne pièce et complétion de mission
 
 ## Audio
 
@@ -456,6 +458,7 @@ Ce document liste les fonctionnalités présentes dans le code actuel.
 - Le paramètre \`?debug\` active le panneau debug
 - Contrôles \`lil-gui\` pour le mode caméra, le mode scène, \`R3F Perf\`, \`Debug Overlay\` et le tuning d'interaction
 - Overlay debug compact pour les contrôles de game state et le statut hand tracking
+- Le changement de mission dans le panneau game-state debug déverrouille les missions repair encore \`locked\` à \`waiting\` pour accélérer les tests
 - Helpers de scène debug
 - Caméra libre debug
 - Overlay \`r3f-perf\`

src/data/gameplay/repairGameConfig.ts

@@ -1,4 +1,5 @@
 export const REPAIR_FRAGMENTATION_FIST_HOLD_SECONDS = 1;
 export const REPAIR_FRAGMENTATION_SEQUENCE_SECONDS = 4;
+export const REPAIR_INTERACTION_RADIUS = 10;
 export const REPAIR_SCAN_PART_SECONDS = 1.2;
 export const REPAIR_REASSEMBLY_SECONDS = 1.4;

src/data/gameplay/repairMissions.ts

@@ -1,5 +1,9 @@
 import type { RepairMissionId } from "@/types/gameplay/repairMission";
-import type { Vector3Scale, Vector3Tuple } from "@/types/three/three";
+import type {
+  ModelTransformProps,
+  Vector3Scale,
+  Vector3Tuple,
+} from "@/types/three/three";
 
 export interface RepairMissionCaseConfig {
   position: Vector3Tuple;
@@ -20,6 +24,7 @@ export interface RepairMissionConfig {
   label: string;
   description: string;
   modelPath: string;
+  modelScale?: ModelTransformProps["scale"];
   stageUiPath: string;
   interactUiPath: string;
   brokenUiPath: string;
@@ -40,13 +45,14 @@ const DEFAULT_REPAIR_CASE = {
   scale: 1.5,
 } satisfies RepairMissionCaseConfig;
 
-export const REPAIR_MISSIONS = {
+export const REPAIR_MISSIONS: Record<RepairMissionId, RepairMissionConfig> = {
   bike: {
     id: "bike",
     label: "E-bike",
     description:
       "Repair the damaged cooling module before relaunching the bike",
-    modelPath: "/models/refroidisseur/model.gltf",
+    modelPath: "/models/ebike/model.gltf",
+    modelScale: 0.25,
     stageUiPath: "/assets/UI/ebike.webm",
     interactUiPath: REPAIR_INTERACT_UI_PATH,
     brokenUiPath: REPAIR_BROKEN_UI_PATH,
@@ -56,7 +62,8 @@ export const REPAIR_MISSIONS = {
       {
         id: "bike-cooling-core",
         label: "Cooling core",
-        nodeName: "Cylinder",
+        modelPath: "/models/refroidisseur/model.gltf",
+        nodeName: "refroidisseur",
         placeholderName: "placeholder_1",
       },
     ],
@@ -74,7 +81,7 @@ export const REPAIR_MISSIONS = {
       {
         id: "bike-glove-decoy",
         label: "Insulation glove",
-        modelPath: "/models/gant/model.gltf",
+        modelPath: "/models/gant_l/model.gltf",
       },
     ],
   },
@@ -166,4 +173,4 @@ export const REPAIR_MISSIONS = {
       },
     ],
   },
-} satisfies Record<RepairMissionId, RepairMissionConfig>;
+};

src/hooks/gameplay/useRepairMovementLocked.ts

@@ -0,0 +1,30 @@
+import { useGameStore } from "@/managers/stores/useGameStore";
+import type { MissionStep } from "@/types/gameplay/repairMission";
+
+export function useRepairMovementLocked(): boolean {
+  return false;
+
+  return useGameStore((state) => {
+    switch (state.mainState) {
+      case "bike":
+        return isRepairMovementLocked(state.bike.currentStep);
+      case "pylone":
+        return isRepairMovementLocked(state.pylone.currentStep);
+      case "ferme":
+        return isRepairMovementLocked(state.ferme.currentStep);
+      case "intro":
+      case "outro":
+        return false;
+    }
+  });
+}
+
+function isRepairMovementLocked(step: MissionStep): boolean {
+  return (
+    step === "inspected" ||
+    step === "fragmented" ||
+    step === "scanning" ||
+    step === "repairing" ||
+    step === "reassembling"
+  );
+}

src/index.css

@@ -397,6 +397,35 @@ canvas {
   letter-spacing: 0.03em;
 }
 
+.repair-movement-lock-indicator {
+  position: fixed;
+  top: 22px;
+  left: 50%;
+  z-index: 10;
+  display: inline-flex;
+  align-items: center;
+  gap: 9px;
+  padding: 9px 13px;
+  border: 1px solid rgba(255, 255, 255, 0.18);
+  border-radius: 999px;
+  background: rgba(5, 9, 16, 0.72);
+  color: rgba(255, 255, 255, 0.88);
+  font-size: 12px;
+  font-weight: 650;
+  letter-spacing: 0.02em;
+  pointer-events: none;
+  transform: translateX(-50%);
+  backdrop-filter: blur(10px);
+}
+
+.repair-movement-lock-indicator__dot {
+  width: 7px;
+  height: 7px;
+  border-radius: 999px;
+  background: #38bdf8;
+  box-shadow: 0 0 14px rgba(56, 189, 248, 0.86);
+}
+
 .scene-loading-overlay {
   position: fixed;
   inset: 0;

src/world/player/PlayerController.tsx

@@ -23,6 +23,7 @@ import {
   PLAYER_WALK_SPEED,
   PLAYER_XZ_DAMPING_FACTOR,
 } from "@/data/player/playerConfig";
+import { useRepairMovementLocked } from "@/hooks/gameplay/useRepairMovementLocked";
 import { InteractionManager } from "@/managers/InteractionManager";
 import type { Vector3Tuple } from "@/types/three/three";
 
@@ -78,6 +79,8 @@ export function PlayerController({
   spawnPosition,
 }: PlayerControllerProps): null {
   const camera = useThree((state) => state.camera);
+  const movementLocked = useRepairMovementLocked();
+  const movementLockedRef = useRef(movementLocked);
   const keys = useRef<Keys>({ ...DEFAULT_KEYS });
   const velocity = useRef(new THREE.Vector3());
   const onFloor = useRef(false);
@@ -104,16 +107,36 @@ export function PlayerController({
     camera.position.copy(capsule.current.end);
   }, [camera, spawnPosition]);
 
+  useEffect(() => {
+    movementLockedRef.current = movementLocked;
+
+    if (!movementLocked) return;
+
+    keys.current = { ...DEFAULT_KEYS };
+    wantsJump.current = false;
+    velocity.current.setX(0);
+    velocity.current.setZ(0);
+  }, [movementLocked]);
+
   useEffect(() => {
     const interaction = InteractionManager.getInstance();
 
     const handleKeyDown = (event: KeyboardEvent): void => {
       if (setMovementKey(keys.current, event.key, true)) {
+        if (movementLockedRef.current) {
+          keys.current = { ...DEFAULT_KEYS };
+        }
         event.preventDefault();
         return;
       }
 
       if (event.key === JUMP_KEY) {
+        if (movementLockedRef.current) {
+          wantsJump.current = false;
+          event.preventDefault();
+          return;
+        }
+
         wantsJump.current = true;
         event.preventDefault();
         return;
@@ -172,10 +195,12 @@ export function PlayerController({
     }
 
     _wishDir.set(0, 0, 0);
-    if (keys.current.forward) _wishDir.add(_forward);
-    if (keys.current.backward) _wishDir.sub(_forward);
-    if (keys.current.left) _wishDir.sub(_right);
-    if (keys.current.right) _wishDir.add(_right);
+    if (!movementLocked) {
+      if (keys.current.forward) _wishDir.add(_forward);
+      if (keys.current.backward) _wishDir.sub(_forward);
+      if (keys.current.left) _wishDir.sub(_right);
+      if (keys.current.right) _wishDir.add(_right);
+    }
     if (_wishDir.lengthSq() > 0) _wishDir.normalize();
 
     const accel = onFloor.current