# TURBULENCE — Immediate Next Steps (Concrete, Non-Abstract)
### Exact implementation checklist for the next 3-5 sessions

This is intentionally tactical. Each step has:
- exact file(s) to create/edit
- what to paste/build
- test to run before moving on

---

## Session 1 (2-3 hours): Plane Tilt Greybox + Sliding Props

## Step 1. Create scene and hierarchy
Create scene: `Assets/Scenes/Flight_BudgetLiner_Greybox.unity`

Hierarchy:
- `FlightRoot`
  - `PlaneRoot`
    - `PlaneInterior` (cube floor + wall cubes)
    - `PlaneLooseProps` (empty)
  - `Systems`
  - `SpawnPoints`

## Step 2. Add 12 loose rigidbodies
Create 12 cubes/capsules as props under `PlaneLooseProps`.
For each prop:
- Rigidbody: Mass 2
- Drag 0
- Angular Drag 0.05
- Collision Detection: Continuous Dynamic

## Step 3. Create `PlaneTiltDebugController.cs`
Path: `Assets/Scripts/StormScape/Turbulence/Plane/PlaneTiltDebugController.cs`

Implement:
- Q/E controls roll target
- R/F controls pitch target
- smooth damp current rotation to target
- apply to `PlaneRoot` transform

Pseudo core:
```csharp
[SerializeField] Transform planeRoot;
[SerializeField] float maxRoll = 25f;
[SerializeField] float maxPitch = 10f;
[SerializeField] float tiltSpeed = 4f;

void Update()
{
  float rollInput = (Input.GetKey(KeyCode.E) ? 1 : 0) - (Input.GetKey(KeyCode.Q) ? 1 : 0);
  float pitchInput = (Input.GetKey(KeyCode.R) ? 1 : 0) - (Input.GetKey(KeyCode.F) ? 1 : 0);

  targetRoll = Mathf.Clamp(targetRoll + rollInput * 25f * Time.deltaTime, -maxRoll, maxRoll);
  targetPitch = Mathf.Clamp(targetPitch + pitchInput * 15f * Time.deltaTime, -maxPitch, maxPitch);

  var target = Quaternion.Euler(targetPitch, 0f, -targetRoll);
  planeRoot.rotation = Quaternion.Slerp(planeRoot.rotation, target, 1f - Mathf.Exp(-tiltSpeed * Time.deltaTime));
}
```

## Step 4. Test gate
PASS only if:
- props slide naturally when banking > 10°
- no explosive physics jitter
- returning to level stabilizes props

Do not move on if this fails.

---

## Session 2 (2-3 hours): Turbulence pulses + player impact into dazed

## Step 1. Add `TurbulencePulseController.cs`
Path: `Assets/Scripts/StormScape/Turbulence/Plane/TurbulencePulseController.cs`

Fields:
- `float minInterval = 1.5f`
- `float maxInterval = 3.5f`
- `float linearImpulseMin = 1.5f`
- `float linearImpulseMax = 4.0f`
- `Rigidbody[] affectedBodies`

Behavior:
- coroutine loops forever
- waits random interval
- picks random impulse direction biased by plane right/forward
- applies `AddForce(impulse, ForceMode.Impulse)` to props

## Step 2. Wire into existing `PlayerImpactReceiver`
No architecture changes yet. Just confirm impact thresholds hit from turbulence-object collisions.
Set start thresholds:
- dazeThreshold = 6
- unconsciousThreshold = 11.5

## Step 3. Add quick debug overlay
Create tiny OnGUI in scene showing:
- last impulse magnitude
- current player state
- last impact magnitude

## Step 4. Test gate
PASS if:
- turbulence causes occasional daze state in < 90 seconds
- unconscious can still happen from heavy object impact
- no permanent lock in dazed/unconscious

---

## Session 3 (3-4 hours): Engine crisis chain skeleton (host-only local for now)

## Step 1. Create enums + runtime classes
Create:
- `Assets/Scripts/StormScape/Turbulence/Crisis/CrisisType.cs`
- `Assets/Scripts/StormScape/Turbulence/Crisis/CrisisState.cs`
- `Assets/Scripts/StormScape/Turbulence/Crisis/CrisisRuntime.cs`

Enums:
- `EngineOverheat`
- `EngineFire`
- `EngineFailure`

States:
- `Inactive`
- `Active`
- `Resolved`
- `Escalated`

## Step 2. Create `SimpleCrisisManager.cs`
Path: `Assets/Scripts/StormScape/Turbulence/Crisis/SimpleCrisisManager.cs`

MVP logic only:
- Start in Overheat after 20s
- If unresolved 35s -> Fire
- If unresolved 40s -> Failure
- If Fire resolved -> end chain

## Step 3. Add world marker objects
In scene, create:
- `EnginePanel_OverheatMarker` (yellow emissive cube)
- `EnginePanel_FireMarker` (red emissive + particle)

Manager toggles markers by crisis state.

## Step 4. Test gate
PASS if:
- chain progresses by timer automatically
- resolving fire prevents failure
- failure state locks and persists

---

## Session 4 (4-5 hours): Grab extinguisher + repair interaction

## Step 1. Create extinguisher prefab
Use current grabbable system.
Prefab path: `Assets/Prefabs/Items/Extinguisher.prefab`
Set ItemData:
- carryMode: OneHanded
- throw multiplier: 0.8
- mass: 3

## Step 2. Create `EngineRepairInteractable.cs`
Path: `Assets/Scripts/StormScape/Turbulence/Crisis/EngineRepairInteractable.cs`
Implements `IInteractable`.

Rules:
- CanInteract only if active crisis == EngineFire
- Requires player currently holding Extinguisher item
- Hold interact accumulates progress
- 6 seconds total resolve time
- interrupt resets 50% progress decay/sec (not full instant reset)

## Step 3. Hook to `SimpleCrisisManager`
- `ResolveEngineFire(float amount)` API
- called every interact tick while valid

## Step 4. Test gate
PASS if:
- player can grab extinguisher
- hold interaction visibly progresses
- releasing interact slows/loses progress
- full progress resolves fire

---

## Session 5 (3-4 hours): Convert these systems to host-authoritative NGO

## Step 1. Make `SimpleCrisisManager` a `NetworkBehaviour`
- host writes crisis state NetworkVariable
- clients read-only

## Step 2. Interaction requests via ServerRpc
In interactor:
- client sends StartInteractServerRpc(targetNetId)
- host validates target + tool + range
- host ticks progress

## Step 3. Grabbable authority fix
Do not attach carry joint until ownership confirmed.
Implement pending state:
- request ownership
- wait callback `OnOwnershipChanged`
- then attach joint

## Step 4. Sync minimal UI
Client UI reads network crisis state and progress.

## Step 5. Test gate (host+1 client)
PASS if:
- both see same crisis phase/timers
- client can repair and host state updates
- no duplicate ownership on extinguisher
- landing result (even placeholder) matches both clients

---

## Fast Fallback Plan (if blocked)

If networking blocks progress, do this for 1 day:
1. Finish all logic single-player host-side
2. add extensive debug logs
3. then wrap with NGO

Never debug networking + game logic unknowns at same time.

---

## Minimal Script List You Should Have After This

- `PlaneTiltDebugController.cs`
- `TurbulencePulseController.cs`
- `SimpleCrisisManager.cs`
- `EngineRepairInteractable.cs`
- `CrisisRuntime.cs`
- `CrisisType.cs`
- `CrisisState.cs`

If these are in and passing gates, you have a real MVP slice.

---

## What to send me after Session 5

Send:
1. screenshot of hierarchy
2. screenshot of inspector values for thresholds
3. 30-60s clip of host+client crisis repair
4. any console errors

Then I’ll give you a focused tuning pass and next exact steps (electrical chain + blackout).