TURBULENCE — MVP Build Plan (Crisis + Plane + Systems)

Step-by-step implementation plan for a playable vertical slice

Target: prove the core fun in 2-3 weeks

---

1) Goal of this Plan

This plan is for one thing:

Build a testable MVP slice where 2-4 players are inside a greyboxed plane, the plane tilts/turbulates, one crisis chain happens, players must fix it, and then land or crash.

If this loop is fun, keep building. If not, pivot early.

---

2) MVP Success Criteria (Definition of Done)

A build counts as MVP-complete only if all are true:

1. Host + 1 client can join and play a full 5-minute flight.
2. Plane supports tilt + turbulence with objects sliding.
3. One complete crisis chain exists:
   • Engine Overheat → Engine Fire → Engine Failure.
4. Players can:
   • move,
   • grab/carry tools,
   • perform a repair interaction,
   • get ragdolled/unconscious from impacts.
5. Landing result screen resolves to one of:
   • Safe Landing,
   • Rough Landing,
   • Crash.
6. Flight ends with a simple score summary.

If any point fails, do not add content. Fix foundation first.

---

3) Scope Guardrails (Hard Rules)

For this MVP:

• One plane only: Budget Liner greybox.
• One route: straight pseudo-route (no world streaming).
• One crisis chain only (engine line).
• No cosmetics, no progression, no NPC passengers yet.
• No custom netcode tricks beyond NGO host-authoritative baseline.

You are validating gameplay, not shipping content.

---

4) Architecture Snapshot for MVP

4.1 Runtime Ownership

• Host is authoritative for:
  • plane state,
  • crisis state,
  • physics object truth,
  • landing outcome.
• Client owns:
  • input,
  • camera,
  • local FX/audio presentation.

4.2 Core Runtime Systems for MVP

1. PlaneController (host): orientation, turbulence impulses, flight phase.
2. PlaneSubsystems (host): engine temp/health/failure state.
3. CrisisManager (host): spawns and advances engine crisis chain.
4. RepairInteractable (host validated): hold-to-repair.
5. GrabSystem (owner request, host validated): tools + extinguisher.
6. ImpactReceiver/StateController: daze/unconscious from collisions.
7. LandingEvaluator (host): computes final result.
8. FlightOrchestrator: sequence (Boarding → Flight → Landing → Result).

---

5) ECM2 + Gravity Plan (Important)

You're using ECM2 (Easy Character Movement 2). The critical challenge is airplane tilt + gravity behavior.

5.1 What to do for MVP

Use hybrid gravity approach:

• Keep world gravity at normal Physics.gravity = (0, -9.81, 0).
• Rotate the plane interior root transform to simulate bank/pitch.
• For ECM2 characters:
  • drive character movement relative to plane interior orientation,
  • apply custom "ground alignment" via floor normal checks,
  • preserve simple movement first (don't over-customize ECM2 internals yet).

This avoids rewriting the controller while still getting sliding and tilt.

5.2 ECM2 Integration Steps

1. Keep your existing TurbulenceCharacter as movement owner.
2. Add PlaneReferenceProvider to player on spawn:
   • gives access to current plane interior transform.
3. In movement update:
   • compute movement input in camera space,
   • project onto plane interior's local "walk plane".
4. Add CharacterGravityAdapter:
   • when inside plane: use down vector = -planeInterior.up for grounding checks (visual/orientation logic),
   • physics remains world gravity for rigidbodies.
5. Validate edge cases:
   • steep bank (~25°),
   • severe bank (~40°),
   • turbulence impulse while airborne.

5.3 Future (not MVP)

Post-MVP, if needed:

• full custom gravity vector support in ECM2,
• local gravity zones (inside vs wing exterior),
• suction/breach directional force fields.

---

6) Greyboxing the Aircraft (Step-by-step)

6.1 Scene and hierarchy

Create scene: Flight_BudgetLiner_Greybox.unity

Hierarchy:

FlightRoot
  PlaneRoot
    PlaneVisual_Greybox
      CockpitZone
      FirstClassZone
      EconomyZone
      CargoZone
      WingAccessZone
    PlanePhysicsRoot
      LoosePropsRoot
  SystemsRoot
    FlightOrchestrator
    CrisisManager
    PlaneSubsystems
    LandingEvaluator
  SpawnRoot
    PlayerSpawn_Host
    PlayerSpawn_Client1
    PlayerSpawn_Client2
    PlayerSpawn_Client3
  DebugRoot
    DebugFlightUI

6.2 Dimensions (use these numbers first)

• Cabin length: 24m
• Cabin width: 3.6m
• Cabin height: 2.4m
• Aisle width: 0.9m
• Seat block height: 1.1m
• Cargo hold tunnel height: 1.8m

Use primitives only:

• Cubes for walls/floor/seats.
• Capsule blockers for aisle tests.

6.3 Critical colliders

• Continuous floor collider (single mesh collider or tiled boxes).
• Seat colliders (simplified, not high poly).
• Doorway colliders for bottlenecks.
• Cargo hatch opening with trigger for zone switching.

6.4 Greybox interaction anchors

Place empties:

• EnginePanel_A_Anchor
• ExtinguisherWallMount_A
• ToolboxAnchor_A
• RepairStation_A
• CockpitYokeAnchor

These anchors become prefab references later.

---

7) Plane and Flight Phase System

7.1 Flight phases (MVP)

Boarding (20s)
  -> Cruise (120s)
  -> CrisisEscalation (120s)
  -> Landing (40s)
  -> Results

7.2 FlightOrchestrator implementation

Responsibilities:

• Start phase timers.
• Notify CrisisManager of phase changes.
• Trigger turbulence intensity profile.
• Trigger landing mode at the end.

Pseudo-structure:

public enum FlightPhase { Boarding, Cruise, CrisisEscalation, Landing, Results }

public class FlightOrchestrator : NetworkBehaviour
{
    [SerializeField] private PlaneController plane;
    [SerializeField] private CrisisManager crises;
    [SerializeField] private LandingEvaluator landing;

    private NetworkVariable<FlightPhase> currentPhase = new(...);

    public override void OnNetworkSpawn()
    {
        if (!IsServer) return;
        StartCoroutine(RunFlightLoop());
    }

    private IEnumerator RunFlightLoop() { ... }
}

7.3 PlaneController (MVP behavior)

Host updates at FixedUpdate:

• Base cruise attitude target: slight nose up (+2°).
• Apply pilot input (if player is in cockpit seat).
• Apply turbulence offsets from profile.
• Apply damage penalties (engine fail adds roll drift).
• Smooth orientation with damping.

Output:

• synced plane transform,
• current speed scalar,
• stability scalar.

---

8) Crisis System (MVP Engine Chain)

8.1 Crisis chain definition

Single chain:

1. EngineOverheat

   • starts during Cruise/CrisisEscalation.
   • if unresolved in 35s -> EngineFire.

2. EngineFire

   • active flames + alarm.
   • can be resolved by extinguisher interaction (hold spray 6s cumulative).
   • if unresolved in 40s -> EngineFailure.

3. EngineFailure

   • permanent for this run.
   • plane gets roll bias and reduced control authority.

8.2 CrisisDefinitionSO for MVP

Create 3 assets:

• CD_EngineOverheat
• CD_EngineFire
• CD_EngineFailure

Fields needed now:

• id
• displayName
• durationToEscalate
• requiredToolType
• resolveDuration
• nextCrisisId

8.3 CrisisManager host flow

• On phase enter Cruise, schedule EngineOverheat after random 20-40s.
• Keep dictionary of active crises.
• Tick each active crisis:
  • check resolve progress,
  • check escalation timer,
  • transition if needed.
• Emit events for audio/UI.

8.4 repair interaction path

Flow:

1. Player grabs extinguisher.
2. Player targets EnginePanelRepairInteractable.
3. Hold interact starts repair stream.
4. Progress accumulates only while:
   • correct tool equipped,
   • in range,
   • uninterrupted.
5. On completion:
   • host resolves EngineFire.

---

9) Plane Subsystems (MVP)

Create PlaneSubsystems with only engine for now:

EngineSubsystem
  temperature (0-100)
  health (0-100)
  state: Normal / Overheat / Fire / Failed

Rules:

• Overheat increases temp steadily.
• Fire decreases health steadily.
• Failed sets health = 0 and locks state.

Expose to other systems:

• GetEngineState()
• ApplyEngineExtinguish(delta)
• IsEngineFailed

---

10) Tools + Interaction Integration

10.1 MVP tools

Only two tools needed:

• Extinguisher (functional)
• Wrench (dummy placeholder for future)

10.2 Grab system rules

• One held item max for MVP.
• Ownership request must be confirmed before attach joint.
• Drop on unconscious.
• Throw velocity capped.

10.3 Interaction raycast

PlayerInteractor:

• Raycast from camera center.
• Detect IInteractable.
• Show prompt (Use, Repair, Revive).
• Start/stop interaction via input hold.

---

11) Turbulence and Impact (MVP)

11.1 turbulence profiles

Create 3 ScriptableObjects:

• TP_Light: impulse 1-2 m/s, interval 2.5-4.0s
• TP_Medium: impulse 2-4 m/s, interval 1.4-2.8s
• TP_Severe: impulse 4-7 m/s, interval 0.8-1.6s

11.2 application

Host each turbulence pulse:

• offset plane orientation a bit,
• apply impulse to loose rigidbodies,
• notify players for camera shake event.

11.3 impact thresholds (starting values)

In PlayerImpactReceiver:

• Daze at impact magnitude >= 6.0
• Unconscious at impact magnitude >= 11.5
• Impact cooldown: 0.35s

Tune after first playtest.

---

12) Landing System (MVP)

12.1 simplified landing evaluator

Inputs:

• vertical speed at touchdown
• roll angle at touchdown
• engine failed?
• unresolved critical crisis?

Outcome table:

• Safe Landing:

  • vertical speed < 4.5
  • roll < 10°
  • no unresolved fire

• Rough Landing:

  • vertical speed < 8.0
  • roll < 20°

• Crash:

  • everything else

12.2 landing sequence

When entering Landing phase:

• reduce turbulence to medium,
• enable runway trigger collider zone,
• collect touchdown metrics for 5s,
• finalize result.

---

13) Multiplayer Test Matrix (for this MVP)

13.1 mandatory tests

1. Host + 1 client join flight.
2. Client can grab extinguisher and repair fire.
3. Host can grab extinguisher and repair fire.
4. Ownership handoff on dropped item works both ways.
5. Turbulence causes both players to desync-check visually acceptable.
6. One player goes unconscious; revives and recovers.
7. Flight completes and both see same landing result.

13.2 known acceptable imperfections in MVP

• Minor ragdoll mismatch between client and host.
• Occasional item micro-jitter while carried.
• UI prompts slightly delayed under high ping.

Not acceptable:

• duplicate item ownership,
• crisis resolved on one client but not host,
• player stuck unconscious forever,
• mismatch in final landing result.

---

14) Step-by-step Build Order (Do this exactly)

Phase A — Greybox + Plane Core (2-3 days)

1. Build Flight_BudgetLiner_Greybox scene.
2. Add PlaneRoot and interior primitives.
3. Add spawn points.
4. Add PlaneController that can tilt with debug keys.
5. Validate sliding props behavior.

Checkpoint A:

• You can walk in cabin and see objects slide when plane banks.

Phase B — Flight Loop (2 days)

1. Add FlightOrchestrator with phase timers.
2. Add debug UI showing current phase and timer.
3. Add transition to landing and result screen.

Checkpoint B:

• Full timed loop runs with no crises yet.

Phase C — Crisis Chain (3 days)

1. Implement PlaneSubsystems engine state.
2. Implement CrisisManager minimal runtime.
3. Add Overheat->Fire->Failure chain.
4. Add alarm/audio hooks.

Checkpoint C:

• Crisis escalates automatically if ignored.

Phase D — Tool + Repair (2 days)

1. Place extinguisher prefab.
2. Integrate grab + ownership-confirm attach.
3. Add engine repair interactable.
4. Complete fire suppression flow.

Checkpoint D:

• Player can prevent engine failure by correct interaction.

Phase E — Turbulence + Impact + States (2 days)

1. Add turbulence profiles and pulses.
2. Wire impact receiver thresholds.
3. Ensure dazed/unconscious transitions work.
4. Drop held item on unconscious.

Checkpoint E:

• Turbulence materially disrupts repairs.

Phase F — Multiplayer Validation (2-3 days)

1. Run full host/client tests matrix.
2. Fix authority/race bugs.
3. Add debug logs for ownership/crisis transitions.

Checkpoint F:

• Stable 5-minute host+client run.

---

15) Debugging Tools You Should Add Immediately

1. Plane Debug Panel
   • phase, tilt, turbulence profile, speed
2. Crisis Debug Panel
   • active crises, timers, escalate ETA
3. Network Debug Panel
   • object owner IDs, ping, packet loss
4. Player State Panel
   • state type, impact magnitude, held item

These should be toggled with F1/F2/F3 for rapid iteration.

---

16) Risks and Mitigations

Risk 1: ECM2 + tilted floor weirdness

Mitigation:

• Start with moderate max bank (<= 25°) in MVP.
• Keep severe roll only for short pulses.
• Tune grounding and step offsets against slopes.

Risk 2: grab ownership race bugs

Mitigation:

• enforce ownership-confirm callback before joint attach.
• add timeout fallback (cancel pending grab).

Risk 3: crisis feels like UI task, not physical chaos

Mitigation:

• ensure repair station is not trivial to stand at.
• place it where turbulence causes movement disruption.
• require repositioning during interaction.

Risk 4: MVP too broad

Mitigation:

• if behind schedule, cut:
  • wrench,
  • revive interaction,
  • client-side fancy effects.
• Keep core loop only.

---

17) Deliverables Checklist (what to commit)

By end of MVP slice:

• Flight_BudgetLiner_Greybox.unity
• PlaneController.cs
• FlightOrchestrator.cs
• PlaneSubsystems.cs
• CrisisManager.cs
• CrisisDefinitionSO assets x3
• TurbulenceProfileSO assets x3
• EngineRepairInteractable.cs
• Working extinguisher prefab + item data
• Landing result panel
• Debug overlays (phase/crisis/network/player)
• Test report markdown with pass/fail for matrix

---

18) First Playtest Script (30 minutes)

1. Run host + client.
2. Start flight.
3. Do nothing for first crisis and observe escalation.
4. Restart and attempt repair with extinguisher.
5. Introduce turbulence severe mode mid-repair.
6. Test unconscious via thrown object impact.
7. Complete landing.
8. Review:
   • Was it chaotic?
   • Was it readable?
   • Did both players feel useful?

If answer to any is no, tune before adding any new features.

---

19) Next Step after MVP slice passes

Only then move to:

• second crisis chain (electrical/blackout),
• second tool (wire cutters),
• basic passenger NPCs,
• better cockpit interactions.

Do not expand before this MVP is fun.

---

Final Note

This plan is deliberately strict. It gets you to proof-of-fun fast.

You are not building the full game yet. You are proving this sentence:

"Two players inside a tilting plane trying to stop an engine fire is chaotic and fun enough to carry the game."