# Remaining Blueprint Build Order — All 135 Systems

**Version:** 1.1 | **Generated:** 2026-05-21 | **C++ Status:** 22 header files (12 full, 10 stubs)

This document is the authoritative "what's left to build" reference. It cross-references the 22 C++ classes in `Source/PG_Framework/` against all 135 Blueprint spec files to show exactly what Blueprint assets remain to be created, in dependency-safe build order.

---

## Legend

| Symbol | Meaning |
|--------|---------|
| ✅ | **Done** — C++ full implementation + BP spec complete. Zero BP build needed (or Data Asset instance only). |
| 🟡 | **C++ Stub** — C++ header exists (UCLASS, basic vars, delegates). Logic must be implemented in Blueprint child. |
| 🔵 | **BP Build Required** — Full Blueprint implementation needed. No C++ code exists. Follow the spec's Manual Implementation Guide. |
| ⬜ | **Data Asset Instance** — Create content Data Asset instances (per-item, per-equipment, per-encounter, etc.). Not a code build. |
| ➖ | **None Required** — System is purely architectural (interface or auto-created subsystem). No build step. |

---

## Quick Action Summary

| What | Count |
|------|-------|
| **BP component children to create** (full logic implementation) | 66 |
| **BP component children to create** (C++ stub — add logic to BP child) | 8 |
| **BP actor children to create** | 8 |
| **Widget BPs to create** | 14 |
| **Data Asset instances to create** | Per-project (16 DA_ types → ~200+ instances) |
| **Data Tables to import from CSV** | 11 |
| **Input Actions to create** | 22 |
| **Input Mapping Contexts to create** | 5 |
| **Enums/Structs (in-editor)** | 7 (E_PlayerActionState, E_OverlayState, E_PlayerVitalSignals, E_ActionRequestResult + 3 structs) |

**Total assets to build: ~130 Blueprint assets + ~230 Data Asset instances (content-dependent)**

---

## Build Phase Map

```
Phase 0  → Foundation + Input (01-07, 128) — 8 systems — BUILD FIRST
Phase 1  → Player Core (08-15) — 8 systems
Phase 2  → State Management (130-131) — 2 systems — BUILD BEFORE Phase 1
Phase 3  → Interaction (16-23) — 8 systems
Phase 4  → Inventory (24-34) — 11 systems
Phase 5  → Save/Load (35-43) — 9 systems
Phase 6  → UI (44-57) — 14 systems
Phase 7  → Narrative (58-68) — 11 systems
Phase 8  → Weapons (69-79) — 11 systems
Phase 9  → AI (80-88) — 9 systems
Phase 10 → Adaptive (89-101, 132-133) — 15 systems
Phase 11 → Data Assets (115-127, 129, 134-135) — 16 systems (content instances)
Phase 12 → Meta/Progression (102-103) — 2 systems
Phase 13 → Settings (104-105) — 2 systems
Phase 14 → Polish (106-114) — 9 systems
```

---

## Phase 0 — Foundation + Input (BUILD FIRST)

These 8 systems are the bedrock. Without them, nothing else runs.

### 01 — DA_GameTagRegistry
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/DA_GameTagRegistry.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/01_DA_GameTagRegistry.md` |
| **What to Build** | ⬜ **Data Asset instance** (not a Blueprint child — a Data Asset instance created from the C++ class) |

**Setup Steps:**
1. **Prerequisite:** All 11 Data Tables must already exist (imported from CSV) and registered in `Project Settings → Gameplay Tags → Gameplay Tag Table List`. If not done, go back to the Data Tables section below.
2. In Content Browser, navigate to `Content/Framework/Core/` (create folder if needed)
3. **Right-click → Miscellaneous → Data Asset**
4. In the "Pick Data Asset Class" dialog, type `DA_GameTagRegistry` and select it
5. Name it `DA_GameTagRegistry`
6. **Open the Data Asset** → find the `Tag Data Tables` array property
7. Click `+` eleven times → assign each of the 11 `DT_Tags_*` Data Tables in order
8. Save

**Verification:** Open `DA_GameTagRegistry` → call `GetAllRegisteredTags()` (right-click the asset → "Test Data Asset" or via Blueprint). Should return 300+ tags. If empty, the Data Tables are not registered in Project Settings.

### 02 — FL_GameUtilities
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/FL_GameUtilities.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/02_FL_GameUtilities.md` |
| **What to Build** | ➖ **None.** Static function library — callable from any BP. |
| **Companion** | `02a_ML_GameUtilities.md` — 24 BP macros (no C++ required). Build the Macro Library in BP if using BP-only path. |

### 03 — I_InterfaceLibrary (9 interfaces)
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/I_InterfaceLibrary.h` |
| **BP Spec** | ✅ `docs/blueprints/01-core/03_I_InterfaceLibrary.md` |
| **What to Build** | ➖ **None.** All 9 interfaces (I_Interactable, I_Damageable, I_Persistable, I_Lockable, I_Holdable, I_UsableItem, I_Toggleable, I_Adjustable, I_Inspectable) defined in C++. Implement them on your BP actors. |

### 04 — GI_GameFramework
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/GI_GameFramework.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/04_GI_GameFramework.md` |
| **What to Build** | 🔵 **BP child:** `Content/Framework/Core/BP_GameFramework` (parent: `GI_GameFramework`) |
| **Project Settings** | Set as **Default Game Instance** in Maps & Modes |

**Setup Steps:**
1. In Content Browser, navigate to `Content/Framework/Core/` (create folder if needed)
2. **Right-click → Blueprint Class**
3. In the "Pick Parent Class" dialog, scroll to the bottom and click **"All Classes"**
4. In the search box that appears, type `GI_GameFramework` and select it
5. Name it `BP_GameFramework`
6. **Double-click to open** the Blueprint → click **Class Defaults** (toolbar button at top)
7. In the Details panel, find the **Framework\|Config** category:
   - `Tag Registry` → click the dropdown → select `DA_GameTagRegistry`
   - `b Validate Tags On Init` → check the box (set to `true`)
   - `b Log Tags On Init` → optional — check to see all tags in Output Log on startup
8. **Compile → Save**
9. **Edit → Project Settings → Maps & Modes → Game Instance Class** → select `BP_GameFramework`

**Why a BP child?** `GI_GameFramework` is `UCLASS(Blueprintable)` — you can't use the C++ class directly as Game Instance. UE5 requires a concrete class. The BP child inherits all C++ logic (game phases, session flags, service resolution, tag validation) and lets you override Blueprint events like `Init` or `Shutdown` for project-specific startup logic.

### 05 — GM_CoreGameMode
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/GM_CoreGameMode.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/05_GM_CoreGameMode.md` |
| **What to Build** | 🔵 **BP child:** `Content/Framework/Core/BP_CoreGameMode` (parent: `GM_CoreGameMode`) |
| **Project Settings** | Set as **Default GameMode** in Maps & Modes |

**Setup Steps:**
1. In Content Browser, navigate to `Content/Framework/Core/`
2. **Right-click → Blueprint Class → All Classes** → search `GM_CoreGameMode`
3. Name it `BP_CoreGameMode`
4. **Double-click to open** → click **Class Defaults** (toolbar button at top)
5. The `PlayerControllerClass`, `PlayerStateClass`, `GameStateClass`, and `DefaultPawnClass` are **inherited from `AGameModeBase`** — they appear in the Details panel under the **"Classes"** section (not under Framework). Fill them in:

   | Property | Value | Notes |
   |----------|-------|-------|
   | `Player Controller Class` | `PC_CoreController` | Your BP child of `APC_CoreController` (C++ stub — create it first) |
   | `Player State Class` | `PS_CorePlayerState` | Your BP child of `APS_CorePlayerState` (C++ stub — create it first) |
   | `Game State Class` | `BP_CoreGameState` | Your BP child of `AGS_CoreGameState` |
   | `Default Pawn Class` | Your player pawn BP | The Character BP with all BPC_ components attached |
   | `HUD Class` | `WBP_HUDController` | Your root HUD widget (create later in Phase 6) |

6. **Compile → Save**
7. **Edit → Project Settings → Maps & Modes → Default GameMode** → select `BP_CoreGameMode`

> **Important:** The C++ header explicitly states: *"PlayerControllerClass, PlayerStateClass, and GameStateClass are inherited from AGameModeBase — do not redeclare (UHT forbids shadowing). Set them in your BP child's Class Defaults."* These properties are in the inherited "Classes" category, not in custom Framework categories. If you can't find them, make sure you're looking at Class Defaults (not the Event Graph) and scroll through all categories.

### 06 — GS_CoreGameState
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Core/GS_CoreGameState.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/06_GS_CoreGameState.md` |
| **What to Build** | 🔵 **BP child:** `Content/Framework/Core/BP_CoreGameState` (parent: `GS_CoreGameState`) |

**Setup Steps:**
1. In Content Browser, navigate to `Content/Framework/Core/`
2. **Right-click → Blueprint Class → All Classes** → search `GS_CoreGameState`
3. Name it `BP_CoreGameState`
4. **Compile → Save** (no extra config needed — all 5 replicated state variables with `OnRep_` handlers work out of the box)
5. Assign it in `BP_CoreGameMode` → Class Defaults → Classes → `Game State Class` → `BP_CoreGameState`

**What you get for free:** Chapter tracking, narrative phase, encounter state, objective tags, play time accumulation — all replicated with dispatchers that fire identically for local and remote clients.

### 07 — DA_ItemData
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Inventory/DA_ItemData.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/01-core/07_DA_ItemData.md` |
| **What to Build** | ⬜ **Data Asset instances** (NOT world actors — see note below) |

**How to create each item:**
1. `Content/Framework/DataAssets/Items/` → **Right-click → Miscellaneous → Data Asset**
2. Class: `DA_ItemData` → Name: `DA_Item_[Name]` (e.g., `DA_Item_MedKit`)
3. Open → fill core properties: ItemTag, DisplayName, Description, Icon, WorldMesh, Weight, StackLimit, ItemType
4. Based on ItemType, fill the relevant sub-struct:
   - Weapon/Tool → fill `Equipment Data` (slot, damage, fire rate, magazine size)
   - Consumable → fill `Consumable Data` (health restore, use duration)
   - KeyItem → set `b Is Key Item` = true (auto-protects from drop/clear)
5. Save
6. **To place in world:** Create a `BP_ItemPickup` actor (spec #25), set its `Config.ItemData` to this asset, drag into level.

> **Data Assets are NOT actors.** `DA_ItemData` defines *what* the item is (identity card). `BP_ItemPickup` is the *physical body* in the world. See `docs/blueprints/01-core/07_DA_ItemData.md` for the full explanation with diagrams.

### 128 — SS_EnhancedInputManager
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Input/SS_EnhancedInputManager.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/15-input/128_SS_EnhancedInputManager.md` |
| **What to Build** | ➖ **None.** Auto-created GameInstanceSubsystem. |
| **Manual Steps** | Create 22 IA_* Input Actions + 5 IMC_* Input Mapping Contexts. Create `DA_InputMappingProfile` instances per platform. |

### — PC_CoreController
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/PC_CoreController.h` + `.cpp` |
| **BP Spec** | Covered in 02-player integration docs |
| **What to Build** | 🔵 **BP child:** `Content/Framework/Player/PC_CoreController` (parent: `APC_CoreController`) |

**Setup Steps:**
1. In Content Browser, navigate to `Content/Framework/Player/`
2. **Right-click → Blueprint Class → All Classes** → search `PC_CoreController` (or `APC_CoreController`)
3. Name it `PC_CoreController`
4. **Open → Event Graph → Event BeginPlay:**
   - Get Game Instance → Cast To `BP_GameFramework`
   - Get Subsystem (Class: `SS_EnhancedInputManager`) — auto-created, no need to spawn
   - Call `Push Context` on the subsystem: Context=`IMC_Default`, Priority=0, ContextTag=`Framework.Input.Context.Default`
5. Add input routing logic for game phase transitions (bind to `GI_GameFramework.OnGamePhaseChanged` → show/hide cursor, switch input mode)
6. **Compile → Save**
7. Assign in `BP_CoreGameMode` → Class Defaults → Classes → `Player Controller Class` → `PC_CoreController`

> **C++ stub means:** The C++ class exists solely so UHT can compile forward-declarations from `GM_CoreGameMode`. It has a constructor but no logic. All gameplay behavior (input routing, phase handling, BeginPlay) goes in your BP child.

### — PS_CorePlayerState
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/PS_CorePlayerState.h` + `.cpp` |
| **BP Spec** | Covered in 02-player integration docs |
| **What to Build** | 🔵 **BP child:** `Content/Framework/Player/PS_CorePlayerState` (parent: `APS_CorePlayerState`) |

**Setup Steps:**
1. In Content Browser, navigate to `Content/Framework/Player/`
2. **Right-click → Blueprint Class → All Classes** → search `PS_CorePlayerState` (or `APS_CorePlayerState`)
3. Name it `PS_CorePlayerState`
4. **Open → Class Defaults** (or add replicated variables in Event Graph):
   - Add player-specific replicated state: inventory slot data, equipped items array, narrative flags map
   - Use `Replicated` or `Replicated Using` with `OnRep_` handlers to fire dispatchers
5. **Compile → Save**
6. Assign in `BP_CoreGameMode` → Class Defaults → Classes → `Player State Class` → `PS_CorePlayerState`

> **Why empty?** The C++ stub inherits from `APlayerState` which already has `PlayerName`, `Score`, `Ping`. Add your project's player data (loadout, stats, progression) to this BP child. For multiplayer, mark variables `Replicated` and add `GetLifetimeReplicatedProps` override.

### Data Tables (Phase 0 Root)
| Asset | Status |
|-------|--------|
| `DT_Tags_Player.csv` | ⬜ Import as Data Table (`GameplayTagTableRow`), register in Project Settings |
| `DT_Tags_Interaction.csv` | ⬜ Import, register |
| `DT_Tags_Item.csv` | ⬜ Import, register |
| `DT_Tags_Narrative.csv` | ⬜ Import, register |
| `DT_Tags_AI.csv` | ⬜ Import, register |
| `DT_Tags_Save.csv` | ⬜ Import, register |
| `DT_Tags_Environment.csv` | ⬜ Import, register |
| `DT_Tags_Combat.csv` | ⬜ Import, register |
| `DT_Tags_State.csv` | ⬜ Import, register |
| `DT_Tags_Audio.csv` | ⬜ Import, register |
| `DT_Tags_Achievement.csv` | ⬜ Import, register |

**How to create each Data Table:**
1. In Content Browser, navigate to `Content/Framework/DataTables/` (create folder if needed)
2. **Right-click → Miscellaneous → Data Table**
3. In the "Pick Row Structure" dialog, search and select `GameplayTagTableRow`
4. Name it exactly: `DT_Tags_[Category]` (e.g., `DT_Tags_Player`)
5. **Double-click** the Data Table to open it → click **Import** (toolbar button)
6. Select the corresponding CSV file from the framework source
7. After importing all 11, go to **Edit → Project Settings → Gameplay Tags → Gameplay Tag Table List**
8. Click `+` eleven times → assign each `DT_Tags_*` Data Table
9. **Click the refresh icon** next to "Import Tags from Config" to force tag load
10. Restart the editor to ensure all tags are cached

> **⚠️ Critical:** Without Step 8-9, NO framework gameplay tags will be recognized. `Is Gameplay Tag Valid` returns false for all tags. `DA_GameTagRegistry.ValidateTag()` fails. The CSV files alone are not enough — UE must be told which Data Tables to scan for tags.

### Starter GameInstance (00-project-setup)
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 Superseded by GI_GameFramework (04) |
| **BP Spec** | ✅ `docs/blueprints/00-project-setup/GI_StarterGameInstance.md` |
| **What to Build** | 🔵 **BP child:** `BP_StarterGameInstance` (parent: `GameInstance`) — minimal tag validation entry point. Use this for quick prototyping before migrating to full `BP_GameFramework` (04). |

---

## Phase 1 — Player Core (8 systems)

All 8 Player systems need Blueprint component children. Four have C++ stubs; four are BP-only.

### 08 — BPC_HealthSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/BPC_HealthSystem.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/02-player/08_BPC_HealthSystem.md` |
| **C++ Provides** | `MaxHealth`, `CurrentHealth`, `OnHealthChanged` dispatcher, `OnDeath` dispatcher |
| **BP to Add** | 🔵 Health logic: `TakeDamage()`, `Heal()`, `OnDeath()` transition, damage resistance modifiers, health regen tick. Must implement `I_Damageable`. |
| **Attach To** | Player pawn |

### 09 — BPC_StaminaSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/BPC_StaminaSystem.h` + `.cpp` |
| **C++ Provides** | `MaxStamina`, `CurrentStamina`, `OnExhaustionStateChanged` dispatcher |
| **BP to Add** | 🔵 Stamina logic: sprint drain, action costs, exhaustion state machine, regen delay + rate, `CanAffordAction(Cost)` query. |
| **Attach To** | Player pawn |

### 10 — BPC_StressSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/BPC_StressSystem.h` + `.cpp` |
| **C++ Provides** | `EStressTier` enum (Calm→Catatonic), `StressTier`, `OnStressTierChanged` dispatcher |
| **BP to Add** | 🔵 Stress logic: stress accumulation sources (combat, darkness, scares), decay during safety, tier transitions, hallucination trigger thresholds. |
| **Attach To** | Player pawn |

### 11 — BPC_MovementStateSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/Player/BPC_MovementStateSystem.h` + `.cpp` |
| **C++ Provides** | `CurrentMovementMode` (FGameplayTag), `OnMovementModeChanged` dispatcher |
| **BP to Add** | 🔵 Movement logic: read CMC (CharacterMovementComponent) states, map to GameplayTags, detect posture changes (standing/crouching/prone), sprint state, footstep events, GASP ABP variable bridge. |
| **Attach To** | Player pawn |

### 12 — BPC_HidingSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **BP Spec** | ✅ `docs/blueprints/02-player/12_BPC_HidingSystem.md` |
| **What to Build** | 🔵 **BP child:** `BPC_HidingSystem` — enter/exit hiding, peek, breath-hold timer, LOS raycasts, stress decay multiplier, I_HidingSpot interface queries. |
| **Attach To** | Player pawn |

### 13 — BPC_EmbodimentSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **BP Spec** | ✅ `docs/blueprints/02-player/13_BPC_EmbodimentSystem.md` |
| **What to Build** | 🔵 **BP child:** `BPC_EmbodimentSystem` — first-person body mesh, arm/weapon IK, visibility per state, skin/outfit overlays, shadow casting. |
| **Attach To** | Player pawn |

### 14 — BPC_CameraStateLayer
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **BP Spec** | ✅ `docs/blueprints/02-player/14_BPC_CameraStateLayer.md` |
| **What to Build** | 🔵 **BP child:** `BPC_CameraStateLayer` — FOV, offset, rotation layers per state (combat zoom, hiding peek, inspect FOV), camera shake triggers, look sensitivity scaling. |
| **Attach To** | Player pawn (or CameraComponent) |

### 15 — BPC_PlayerMetricsTracker
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **BP Spec** | ✅ `docs/blueprints/02-player/15_BPC_PlayerMetricsTracker.md` |
| **What to Build** | 🔵 **BP child:** `BPC_PlayerMetricsTracker` — track accuracy, deaths, playstyle ratios, time-to-complete sections, leaderboard data. Feed to SS_AchievementSystem (103). |
| **Attach To** | Player pawn |

---

## Phase 2 — State Management (BUILD BEFORE Phase 1 systems wire up)

These 2 systems are the central nervous system. `BPC_StateManager` must be on the player pawn before any other system calls `IsActionPermitted()`.

### 130 — BPC_StateManager
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Player/BPC_StateManager.h` + `.cpp` |
| **BP Spec** | ✅ `docs/blueprints/16-state/130_BPC_StateManager.md` |
| **What to Build** | ➖ **None.** Attach C++ component directly to player pawn. |
| **Config in Details Panel** | Set `GatingTable` → `DA_StateGatingTable`, `DefaultActionState` → `Framework.State.Action.Idle` |
| **Manual Steps** | Create `E_PlayerActionState` (42 values), `E_OverlayState` (18), `E_PlayerVitalSignals` (5), `E_ActionRequestResult` (8) enums in editor. Create `S_StateChangeRequest`, `S_StateGatingRule`, `S_ActionPermissionResult` structs. |
| **Attach To** | Player pawn (component slot 0 — loads first) |

### 131 — DA_StateGatingTable
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🟡 **Stub** — `Source/PG_Framework/Public/State/DA_StateGatingTable.h` + `.cpp` |
| **C++ Provides** | `FStateGatingRule` struct, `GatingRules` array, `IsActionGated()` query |
| **What to Build** | ⬜ **Data Asset instance:** `Content/Framework/State/DA_StateGatingTable` → populate `GatingRules` with 37 rules mapping action tags to blocking state tags. |
| **Manual Steps** | Populate all 37 gating rules per the architecture doc. Designers modify rules here — no BP changes. |

---

## Phase 3 — Interaction (8 systems)

### 16 — BPC_InteractionDetector
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — raycast-based interaction detection, hold/press timing, prompt generation, focus begin/end events. Calls `I_Interactable` interface on targets. |
| **Attach To** | Player pawn |

### 17 — I_HidingSpot
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** (simple interface) |
| **What to Build** | 🔵 **BP interface:** `I_HidingSpot` — functions: Enter, Exit, Peek, GetEntryTransform, IsOccupied. Implement on hiding spot actors. |

### 18 — BPC_DiegeticDisplay
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — in-world UI rendering on surfaces (wristwatch, monitors, holograms). Coordinates with `SS_UIManager`. |

### 19 — BP_DoorActor
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP actor child** — physical door with open/close/lock/barricade/trap state machine, linked actors, `I_Interactable` + `I_Lockable` + `I_Toggleable`. |

### 20 — BP_PuzzleDeviceActor
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP actor child** — puzzle base: state machine, solution validation, reward dispenser, `I_Interactable`. Set `DA_PuzzleData` per instance. |

### 21 — BPC_ContextualTraversalSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — vault, mantle, slide, squeeze, climb via Motion Warping. Reads environment probes, plays traversal montages. |

### 22 — BPC_PhysicsDragSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — grab, drag, release physics objects. `I_Holdable` interface integration. Physics handle management. |

### 23 — BPC_UsableWorldObjectSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — generic world object use (levers, valves, buttons, panels). `I_Toggleable` + `I_Adjustable` dispatch. |

---

## Phase 4 — Inventory (11 systems)

### 24 — BPC_ContainerInventory
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — world container inventory (chests, drawers, cabinets, safes). `IPersistable` for loot persistence. |

### 25 — BP_ItemPickup
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP actor child** — physical item in world: bob/rotate animation, `I_Interactable`, auto-pickup or manual pickup |

**Setup Steps (3-part workflow):**

**Part A — Create the Data Asset (one-time per item type):**
1. `Content/Framework/DataAssets/Items/` → Right-click → Miscellaneous → Data Asset → Class: `DA_ItemData`
2. Name: `DA_Item_MedKit` → Open → fill: ItemTag, DisplayName, Icon, WorldMesh, Weight, StackLimit, ItemType
3. If ItemType=Consumable → fill ConsumableData (HealthRestore=25, UseDuration=2.0)

**Part B — Create the BP_ItemPickup Blueprint (one-time):**
1. `Content/Framework/Inventory/` → Right-click → Blueprint Class → Actor → name: `BP_ItemPickup`
2. Implement `I_Interactable` interface (Class Settings → Interfaces → Add `UInteractable`)
3. Add Components: `StaticMeshComponent` (named "Mesh"), `SphereComponent` (named "InteractionCollision")
4. Add Variable: `Config` of type `S_PickupConfig`
5. In Construction Script: read `Config.ItemData` → set Mesh to `ItemData.WorldMesh`

**Part C — Place Items in Level (repeat per item instance):**
1. Drag `BP_ItemPickup` into the level
2. Select it → Details panel → Config → Item Data → `DA_Item_MedKit`
3. Set Quantity → 1 (or more for stacked items)
4. Position the actor where you want it

> `DA_ItemData` is NOT an actor — you cannot drag it into the level. It lives in the Content Browser as a Data Asset. `BP_ItemPickup` is the physical body that references the Data Asset. See `docs/blueprints/01-core/07_DA_ItemData.md` for the full explanation.

### 26 — BPC_ActiveItemSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — quick-slot management (1-8 hotkeys), contextual item use, scroll wheel cycling, `I_UsableItem` calls. |

### 27 — BPC_CollectibleTracker
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — collectible tracking: found count, set bonuses, reward unlocks. Feeds `SS_AchievementSystem`. |

### 28 — BPC_ConsumableSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — consumable use: health packs, syringes, temporary buffs. Reads `DA_ItemData.ConsumableData`. |

### 29 — BPC_DocumentArchiveSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — document archive: read, categorize, flag important. Feeds `WBP_JournalDocumentViewer`. |

### 30 — BPC_EquipmentSlotSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — equipment slots (primary weapon, secondary, melee, tool, armor, accessory). Equip/unequip validation, stat recalculation on swap. |

### 31 — BPC_InventorySystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Inventory/BPC_InventorySystem.h` + `.cpp` |
| **What to Build** | ➖ **None.** Attach C++ component directly to player pawn. |

**Setup Steps:**
1. Open your `BP_PlayerCharacter` Blueprint
2. In the Components panel, click **Add Component** → search `BPC_InventorySystem`
3. Select the component → in Details panel:
   - `Grid Width` → `8` (columns)
   - `Grid Height` → `5` (rows — gives 40 total slots)
   - `Max Weight` → `50.0` (set to `0` to disable weight limit)
4. **Compile → Save**

**Usage from Blueprint:**
- Get component: `Get Component by Class (BPC_InventorySystem)`
- `Add Item(ItemData, Quantity)` → returns `int32` (actual quantity added — may be less if full)
- `Can Add Item(ItemData, Quantity)` → returns `bool` (check before showing pickup prompt)
- `Get Item Count(ItemData)` → returns total quantity across all stacks
- `Sort Inventory` — native-speed C++ TArray sort with lambda
- Bind to `On Inventory Changed` dispatcher → UI widgets refresh

**Attach To** | Player pawn (alongside HealthSystem, StaminaSystem, etc. — order doesn't matter for inventory)

### 32 — BPC_ItemCombineSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — item combination/crafting: recipe validation via `DA_ItemData.CombinesWith`/`CombineResult`, result generation. |

### 33 — BPC_JournalSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — quest/objective journal: active, completed, failed tracking. Feeds `WBP_ObjectiveDisplay` + `WBP_JournalDocumentViewer`. |

### 34 — BPC_KeyItemSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — key item tracking: use-on-target, consumed-on-use, `I_Lockable.TryUnlock()` calls. |

---

## Phase 5 — Save/Load (9 systems)

### 35 — SS_SaveManager
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — `Source/PG_Framework/Public/Save/SS_SaveManager.h` + `.cpp` |
| **What to Build** | ➖ **None.** Auto-created GameInstanceSubsystem. |

### 36 — I_Persistable
| Aspect | Detail |
|--------|--------|
| **C++ Status** | ✅ Full — in `Source/PG_Framework/Public/Core/I_InterfaceLibrary.h` |
| **What to Build** | ➖ **None.** Interface already defined. Implement on any actor that needs save/load. |

### 37 — BP_Checkpoint
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP actor child** — checkpoint: respawn point, activation, save-on-touch. Call `SS_SaveManager.CreateCheckpoint()`. |

### 38 — BPC_AltDeathSpaceSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — alternate death/void space: enter, explore, find exit. Coordinates with `BPC_DeathHandlingSystem`. |

### 39 — BPC_DeathHandlingSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — death orchestrator: death cause determination, death animation, respawn timer, death screen trigger. Calls `GM_CoreGameMode.HandlePlayerDead()`. |

### 40 — BPC_PersistentCorpseSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — corpse persistence: spawn corpse actor on death, preserve inventory as lootable, decay timer. |

### 41 — BPC_PersistentWorldStateRecorder
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — world state recording: track door states, destroyed objects, puzzle completions. Feeds `SS_SaveManager`. |

### 42 — BPC_PlayerRespawnSystem
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — respawn logic: nearest checkpoint lookup, respawn animation, invulnerability window, inventory restoration. |

### 43 — BPC_RunHistoryTracker
| Aspect | Detail |
|--------|--------|
| **C++ Status** | 🔵 **BP-Only** |
| **What to Build** | 🔵 **BP child** — run/session history: death count, chapter progress, item collection stats. Feeds post-game analytics. |

---

## Phase 6 — UI (14 systems — ALL Widget Blueprints)

All 14 UI systems are Widget Blueprints. UMG is BP-native — no C++ conversion needed.

| # | System | Asset Type | Parent | Key Dependencies |
|---|--------|-----------|--------|-----------------|
| 44 | `SS_UIManager` | BP child of `GameInstanceSubsystem` | GameInstanceSubsystem | Menu stack, push/pop, HUD visibility, input mode sync |
| 45 | `WBP_AccessibilityUI` | Widget BP | UserWidget | Colorblind modes, subtitle sizes, control remapping |
| 46 | `WBP_DiegeticHUDFrame` | Widget BP | UserWidget | In-world HUD frames (health bar on wristwatch, etc.) |
| 47 | `WBP_HUDController` | Widget BP | UserWidget | Root HUD: health, stamina, stress bars, crosshair, objective |
| 48 | `WBP_InteractionPromptDisplay` | Widget BP | UserWidget | "Press E to Open" prompts, hold-progress bar |
| 49 | `WBP_InventoryMenu` | Widget BP | UserWidget | Grid-based inventory UI, drag-drop, context menu |
| 50 | `WBP_JournalDocumentViewer` | Widget BP | UserWidget | Document reader: text, images, audio logs |
| 51 | `WBP_MainMenu` | Widget BP | UserWidget | New Game, Continue, Load Save, Settings, Quit |
| 52 | `WBP_MenuFlowController` | Widget BP | UserWidget | Menu state machine (Main→Settings→Back, etc.) |
| 53 | `WBP_NotificationToast` | Widget BP | UserWidget | Achievement unlock, item found, objective update popups |
| 54 | `WBP_ObjectiveDisplay` | Widget BP | UserWidget | Active objectives list, progress bars, compass markers |
| 55 | `WBP_PauseMenu` | Widget BP | UserWidget | Resume, Settings, Load, Save, Main Menu, Quit |
| 56 | `WBP_ScreenEffectController` | Widget BP | UserWidget | Vignette, blood splatter, flash, color grading overlays |
| 57 | `WBP_SettingsMenu` | Widget BP | UserWidget | Graphics, Audio, Controls, Accessibility, Language |

---

## Phase 7 — Narrative (11 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 58 | `BPC_NarrativeStateSystem` | BPC child | Narrative state machine: chapter/phase tracking, flag management |
| 59 | `BPC_ObjectiveSystem` | BPC child | Objective tracking: add/complete/fail, prerequisite checking |
| 60 | `BPC_DialoguePlaybackSystem` | BPC child | Dialogue playback: text display, audio sync, auto-advance |
| 61 | `BPC_DialogueChoiceSystem` | BPC child | Dialogue choices: branching, consequence dispatch, timers |
| 62 | `BPC_BranchingConsequenceSystem` | BPC child | Consequence execution: set narrative flags, spawn actors, trigger events |
| 63 | `BPC_TrialScenarioSystem` | BPC child | Timed trial/puzzle: countdown, success/fail conditions |
| 64 | `BPC_CutsceneBridge` | BPC child | Cutscene bridge: enter/exit cutscene phase, camera control, skip |
| 65 | `BPC_LoreUnlockSystem` | BPC child | Lore/journal unlock: trigger-based, item-based discovery |
| 66 | `DA_NarrativeDataAssets` | ⬜ DA instances | Dialogue lines, choice trees, quest definitions |
| 67 | `BP_NarrativeTriggerVolume` | BP actor child | Trigger volume: on-overlap set narrative flags, start dialogue |
| 68 | `BPC_EndingAccumulator` | BPC child | Ending tracker: accumulate ending conditions, determine final outcome |

---

## Phase 8 — Weapons (11 systems)

| # | System | C++ | What to Build |
|---|--------|-----|--------------|
| 69 | `BP_WeaponBase` | 🔵 | BP actor child: weapon base with fire/aim/reload state machine. `I_UsableItem` |
| 70 | `BPC_AmmoComponent` | 🔵 | BP child: ammo pool, reserve/magazine tracking, ammo pickup |
| 71 | `BPC_CombatFeedbackComponent` | 🔵 | BP child: hit markers, damage numbers, kill confirmation |
| 72 | `BPC_DamageReceptionSystem` | ✅ Full | ➖ Attach C++ component directly. Set configs in Details panel. |
| 73 | `BPC_DeathCauseTracker` | 🔵 | BP child: death cause logging, damage history, kill attribution |
| 74 | `BPC_FirearmSystem` | 🔵 | BP child: hitscan/projectile fire, fire rate, spread, recoil |
| 75 | `BPC_HitReactionSystem` | 🟡 Stub | 🔵 BP child: add hit reaction animation selection, stagger/knockdown/ragdoll triggers |
| 76 | `BPC_MeleeSystem` | 🔵 | BP child: melee combo system, hitbox spawning, damage application |
| 77 | `BPC_RecoilSystem` | 🔵 | BP child: recoil pattern playback, recovery, camera kick |
| 78 | `BPC_ReloadSystem` | 🔵 | BP child: reload timing, animation sync, ammo transfer |
| 79 | `BPC_ShieldDefenseSystem` | 🟡 Stub | 🔵 BP child: add shield raise/lower, block detection, break effect |

---

## Phase 9 — AI (9 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 80 | `BP_EnemyBase` | BP actor child | Enemy character: health, damage, AI controller, behavior tree |
| 81 | `BP_PatrolPath` | BP actor child | Patrol path spline: waypoints, pause durations, loop settings |
| 82 | `BPC_AlertSystem` | BP child | Alert state machine: idle→suspicious→alert→combat→search |
| 83 | `BPC_AIStateMachine` | BP child | AI behavior state: patrol, investigate, combat, flee |
| 84 | `AI_BaseAgentController` | BP child of AIController | AI controller: behavior tree runner, perception setup |
| 85 | `BB_AgentBoard` | ⬜ Blackboard def | Blackboard keys: TargetActor, LastKnownPosition, AlertLevel, PatrolIndex |
| 86 | `BPC_AIMemorySystem` | BP child | AI memory: last known locations, threat history, shared squad knowledge |
| 87 | `BPC_AIPerceptionSystem` | BP child | AI perception: sight cone, hearing radius, detection speed |
| 88 | `BPC_BehaviourVariantSelector` | BP child | Behavior variant: coward/aggressive/defensive selection per encounter |

---

## Phase 10 — Adaptive (15 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 89 | `BPC_DifficultyManager` | BP child | Dynamic difficulty: scale damage, spawn counts, puzzle hints |
| 90 | `BPC_FearSystem` | BP child | Fear: AI fear levels, player fear, flee behavior |
| 91 | `BPC_PerformanceScaler` | BP child | Performance: dynamic LOD, particle reduction, cull distance |
| 92 | `BPC_ProceduralEncounter` | BP child | Procedural encounters: spawn enemies/events based on player state |
| 93 | `BPC_AdaptiveEnvironmentDirector` | BP child | Environment director: coordinate atmosphere, audio, light changes |
| 94 | `BPC_AtmosphereStateController` | BP child | Atmosphere: tone/tension tracking, post-process blending |
| 95 | `BPC_AudioAtmosphereController` | 🔵 [DEPRECATED] — replaced by SS_AudioManager (132) |
| 96 | `BPC_LightEventController` | BP child | Light events: flicker, strobe, blackout, color shift |
| 97 | `BPC_MemoryDriftSystem` | BP child | Memory drift: environmental distortion, room mutation |
| 98 | `BPC_PacingDirector` | BP child | Pacing: action/calm cycle management, intensity curve |
| 99 | `BPC_PlaystyleClassifier` | BP child | Playstyle: stealth/combat/exploration classification |
| 100 | `BPC_RareEventSystem` | BP child | Rare events: low-probability special encounters |
| 101 | `BPC_ScareEventSystem` | BP child | Scare events: jump scares, ambient scares, tension buildup |
| 132 | `SS_AudioManager` | 🔵 BP child of GameInstanceSubsystem | Audio subsystem: bus management, room presets, gameplay parameters |
| 133 | `BP_RoomAudioZone` | 🔵 BP actor child | Room audio zone: trigger volume, reverb/occlusion switching |

---

## Phase 11 — Data Assets (16 systems)

All 16 are Data Asset definitions. No code — create Data Asset instances per content item.

| # | System | Instances Needed |
|---|--------|-----------------|
| 115 | `DA_AdaptationRule` | 5-15 (one per difficulty rule) |
| 116 | `DA_AtmosphereProfile` | 5-20 (one per room/zone) |
| 117 | `DA_BehaviourVariant` | 3-5 (coward/aggressive/defensive per enemy type) |
| 118 | `DA_DataAssetArchitecture` | Reference document only |
| 119 | `DA_EncounterData` | Per encounter group (content-driven) |
| 120 | `DA_EquipmentConfig` | 🟡 C++ stub — create instances per equipment piece |
| 121 | `DA_HapticProfile` | 3 (PC/Xbox/PS5 controller profiles) |
| 122 | `DA_InteractionData` | Per interactable object type (content-driven) |
| 123 | `DA_ObjectiveData` | Per quest/objective (content-driven) |
| 124 | `DA_PuzzleData` | Per puzzle device (content-driven) |
| 125 | `DA_RareEvent` | 3-10 rare event definitions |
| 126 | `DA_RoomMutation` | 5-15 room mutation profiles |
| 127 | `DA_ScareEvent` | 10-50 scare event definitions |
| 129 | `DA_InputMappingProfile` | 3 (PC/Xbox/PS5 key binding profiles) |
| 134 | `DA_AudioSettings` | 1 (master bus config, volume defaults) |
| 135 | `DA_RoomAcousticPreset` | Per acoustic zone (small room / outdoor / cave / etc.) |

---

## Phase 12 — Meta/Progression (2 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 102 | `BPC_ProgressStatTracker` | BP child | Progress stats: completion %, item collection, death count |
| 103 | `SS_AchievementSystem` | BP child of GameInstanceSubsystem | Achievement subsystem: unlock conditions, trophy notification, platform API bridge |

---

## Phase 13 — Settings (2 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 104 | `BPC_AccessibilitySettings` | BP child | Accessibility: colorblind, subtitle, control remapping, TTS |
| 105 | `SS_SettingsSystem` | BP child of GameInstanceSubsystem | Settings persistence: save/load config to disk, apply on boot |
| 148 | `BPC_HapticsController` | BP child of ActorComponent | Haptics: GameplayTag-driven force feedback, DualSense triggers, heartbeat pulse |
| 149 | `BPC_RenderPipelineManager` | BP child of ActorComponent | Render pipeline: quality presets, GI/shadows/upscaling per platform, PlanarCapture aware |
| 150 | `BPC_PlatformServiceAbstraction` | BP child of ActorComponent | Central platform authority: detection, SDK routing (Steam/PSN/Xbox/Nintendo), input/GFX/achievement coordination |

---

## Phase 14 — Polish (9 systems)

| # | System | Type | What to Build |
|---|--------|------|--------------|
| 106 | `BPC_AnalyticsTracker` | BP child | Analytics: event telemetry, session metrics |
| 107 | `BPC_DevCheatManager` | BP child | Dev cheats: god mode, no-clip, give item, teleport |
| 108 | `BPC_ErrorHandler` | BP child | Error/crash: graceful shutdown, error log write |
| 109 | `BPC_FPSCounter` | BP child | FPS counter: on-screen perf display |
| 110 | `BPC_LoadingScreen` | BP child | Loading screen: progress bar, tip rotation, chapter art |
| 111 | `BPC_TutorialSystem` | BP child | Tutorial: contextual hints, input prompts, tutorial progression |
| 112 | `WBP_CreditsScreen` | Widget BP | Credits roll |
| 113 | `WBP_DebugMenu` | Widget BP | Debug overlay: state viewer, tag inspector, log viewer |
| 114 | `WBP_SplashScreen` | Widget BP | Boot splash / branding |

---

## Dependency-Safe Build Order (Linear)

If building solo, follow this order to avoid forward-reference compile errors:

```
STEP 1   — 11 Data Tables (import CSV, register in Project Settings)
STEP 2   — DA_GameTagRegistry Data Asset (assign 11 tables)
STEP 3   — GI_GameFramework BP child → set as Default GameInstance
STEP 4   — PC_CoreController + PS_CorePlayerState BP children (stubs)
STEP 5   — GM_CoreGameMode BP child → set class defaults, set as Default GameMode
STEP 6   — GS_CoreGameState BP child
STEP 7   — E_PlayerActionState + E_OverlayState + E_ActionRequestResult + E_PlayerVitalSignals enums
STEP 8   — S_StateChangeRequest + S_StateGatingRule + S_ActionPermissionResult structs
STEP 9   — DA_StateGatingTable Data Asset (37 rules)
STEP 10  — BPC_StateManager component on player pawn
STEP 11  — Player pawn BP → attach all BPC_ components (run the list from Section 6 of project-setup-migration.md)
STEP 12  — Player Core BPs (08-15) — build ONLY those referenced by StateManager first
STEP 13  — 22 IA_* Input Actions + 5 IMC_* Input Mapping Contexts
STEP 14  — DA_InputMappingProfile instances (PC/Xbox/PS5)
STEP 15  — Interaction BPs (16-23) — START with InteractionDetector
STEP 16  — Inventory BPs (24-34) — Core InventorySystem is C++, build supporting BPs
STEP 17  — Save/Load BPs (35-43)
STEP 18  — UI Widgets (44-57) — START with HUDController + UIManager
STEP 19  — Narrative BPs (58-68)
STEP 20  — Weapons BPs (69-79) — Core DamageReception is C++, build supporting BPs
STEP 21  — AI BPs (80-88)
STEP 22  — Adaptive BPs (89-101)
STEP 23  — Meta + Settings + Polish (102-114)
STEP 24  — SS_AudioManager + BP_RoomAudioZone (132-133)
STEP 25  — All DA_* Data Asset instances (content-populated, per project)
STEP 26  — Phase 17: Planar Capture C++ (136-138) — UBPC_PlanarCapture, ABP_PlanarCaptureActor, USS_PlanarCaptureManager
STEP 27  — Phase 17b: Materials (144, 145, 147) — M_CaptureSurface_Master, MPC_CaptureSurface, 7 MI_ instances
STEP 28  — Phase 17c: Blueprint Actors (139-143) — BP_Mirror, BP_Portal, BP_Monitor, BP_HorrorMirror, BP_FakeWindow
STEP 29  — Phase 17d: Data Asset (146) — DA_PlanarCaptureProfile instances
STEP 30  — Phase 17e: Integration — wire to BPC_ScareEventSystem (101), SS_AudioManager (132), BPC_StateManager (130)
```

---

## Per-System Spec References

Every system has a complete spec in `docs/blueprints/` with node-by-node Manual Implementation Guide. Use those to build each BP child. Key architectural docs:

| Doc | Covers |
|-----|--------|
| `docs/architecture/bpc-statemanager.md` | State Manager enum values, gating table rules, force stack pattern |
| `docs/architecture/metasounds-audio-system.md` | Audio bus architecture, room presets, settings integration |
| `docs/architecture/animation-catalog.md` | 14 required animation notifies, montage contracts |
| `docs/architecture/sound-catalog.md` | 150+ sound triggers, 14 surface table entries |
| `docs/architecture/multiplayer-networking.md` | HasAuthority() gates, Server_ RPCs, RepNotify patterns |
| `docs/architecture/blueprint-limitations-workarounds.md` | C++-only functions you'll encounter during BP implementation |
| `docs/architecture/planar-capture-system.md` | Mirror/portal/monitor/horror capture system architecture (12 systems, Phase 17) |
| `docs/developer/cpp-integration-guide.md` | Per-C++-class setup steps, usage patterns, BP child requirements |

---

## Counting Summary

| Asset Type | Total | C++-Covered | BP to Build |
|-----------|-------|------------|-------------|
| **BP Components (BPC_)** | 80 | 5 full C++, 8 stubs | 67 BP children (8 have C++ stubs to extend) |
| **BP Actors (BP_)** | 16 | 1 full C++ | 15 BP actor children |
| **Widget BPs (WBP_)** | 14 | 0 | 14 Widget BPs |
| **Data Assets (DA_)** | 19 | 3 full C++, 2 stubs | ~200+ DA instances (content-driven) |
| **GameInstance Subsystems (SS_)** | 7 | 3 full C++ | 4 BP children |
| **World Subsystems (SS_)** | 1 | 1 full C++ | 0 |
| **Materials (M_)** | 1 | 0 | 1 Material |
| **Material Instances (MI_)** | 7 | 0 | 7 MICs |
| **MPC** | 1 | 0 | 1 MPC |
| **Interfaces (I_)** | 10 | 9 in C++ | 1 (I_HidingSpot) |
| **Function Libraries (FL_)** | 2 | 2 in C++ | 0 |
| **GameInstance (GI_)** | 1 | 1 in C++ | 1 BP child |
| **GameMode (GM_)** | 1 | 1 in C++ | 1 BP child |
| **GameState (GS_)** | 1 | 1 in C++ | 1 BP child |
| **PlayerController (PC_)** | 1 | 1 stub | 1 BP child |
| **PlayerState (PS_)** | 1 | 1 stub | 1 BP child |
| **Data Tables** | 11 | 0 | 11 imports |
| **Input Actions** | 22 | 0 | 22 create |
| **Input Mapping Contexts** | 5 | 0 | 5 create |
| **Enums** | 4 | 2 in C++ | 2 to create in editor |
| **Structs** | 3 | 1 in C++ | 2 to create in editor |

**Most critical build:** `BPC_StateManager` (130) + `DA_StateGatingTable` (131) — without these, no system can query whether an action is permitted. Build these immediately after Foundation.

---

*Remaining Blueprint Build Order v1.1 — Companion to `cpp-blueprint-status.md` and `cpp-integration-guide.md`.*