Add Project Prototype Guide for PG_Framework Testing Setup

- Introduced a comprehensive guide for creating a minimal playable prototype in UE5. - Detailed steps for project creation, C++ module integration, gameplay tags setup, and player pawn assembly. - Included instructions for input system setup, state management wiring, and test level setup. - Provided a verification checklist and troubleshooting section to assist developers. - Documented next steps for expanding the prototype with additional systems.
2026-05-21 18:03:15 +03:00
parent cd0ebf2233
commit 8bb162eda2
5 changed files with 1515 additions and 53 deletions
--- a/docs/blueprints/INDEX.md
+++ b/docs/blueprints/INDEX.md
@@ -1,9 +1,18 @@
 # Master Blueprint Index — UE5 Modular Game Framework
-**Version:** 3.2 | **Generated:** 2026-05-20 | **Total Files:** 135 numbered + 1 starter + 1 supplementary (137 total specs)
+**Version:** 3.3 | **Generated:** 2026-05-21 | **Total Files:** 135 numbered + 1 starter + 1 supplementary (137 total specs) | **C++:** 22 source files
 This document is the canonical index of every Blueprint specification file in the framework. Each entry links to its full spec document and includes: file name, asset type, parent class, purpose summary, and key dependencies.
 ### Companion Documents
 | Document | Path | Purpose |
 |----------|------|---------|
 | **Remaining BP Build Order** | [`../checklists/remaining-blueprint-build-order.md`](../checklists/remaining-blueprint-build-order.md) | Prioritized list of every BP asset to build, with C++ status per system |
 | **C++/BP Status Grid** | [`../checklists/cpp-blueprint-status.md`](../checklists/cpp-blueprint-status.md) | Complete 135-system grid: C++ status, BP spec status, remaining assets |
 | **C++ Integration Guide** | [`../developer/cpp-integration-guide.md`](../developer/cpp-integration-guide.md) | Per-C++-class setup steps, usage patterns, BP child requirements |
 | **Prototype Setup Guide** | [`../developer/project-prototype-guide.md`](../developer/project-prototype-guide.md) | Step-by-step from blank project to working prototype |
 ---
 ## Directory Map
--- a/docs/checklists/cpp-blueprint-status.md
+++ b/docs/checklists/cpp-blueprint-status.md
@@ -1,18 +1,23 @@
 # C++ & Blueprint Status Checklist — All 135 Systems
-**Version:** 1.0 | **Generated:** 2026-05-20
+**Version:** 2.0 | **Generated:** 2026-05-21 | **C++ Files:** 22 `.h` + 22 `.cpp` (12 full implementations + 10 stubs)
 Complete status grid for every system in the UE5 Modular Game Framework. Use this to track: which systems have C++ code written, which Blueprint specs are complete, and what Blueprint assets remain to create.
 **Companion docs:**
 - **Remaining BP build order:** [`docs/checklists/remaining-blueprint-build-order.md`](remaining-blueprint-build-order.md)
 - **Prototype setup guide:** [`docs/developer/project-prototype-guide.md`](../developer/project-prototype-guide.md)
 - **C++ per-class integration:** [`docs/developer/cpp-integration-guide.md`](../developer/cpp-integration-guide.md)
 ---
 ## Legend
 | Symbol | Meaning |
 |--------|---------|
-| ✅ | **Done** — C++ files written, BP spec complete |
+| ✅ | **Done** — Full C++ implementation with logic + BP spec complete |
-| 🟡 | **Partial** — C++ stub (references siblings, needs subsystem wiring) |
+| 🟡 | **C++ Stub** — C++ header exists (UCLASS, basic vars, delegates). Blueprint child provides the full runtime implementation. |
-| 🔵 | **BP Spec Only** — Full Blueprint spec exists, no C++ written |
+| 🔵 | **BP Spec Only** — Full Blueprint spec exists, no C++ written. Full BP implementation required. |
 | ⬜ | **Content Asset** — Create Data Asset/Table instances (not code) |
 | ❌ | **Not Started** — Spec exists but asset not created |
@@ -58,14 +63,16 @@ Abbreviations:
 | # | System | C++ H/CPP | BP Spec | BP Asset to Create | Status |
 |---|--------|-----------|---------|--------------------|--------|
-| 08 | `BPC_HealthSystem` | 🔵 BP-only | ✅ `08_BPC_HealthSystem.md` | BP child → attach to pawn | 🔵 |
+| 08 | `BPC_HealthSystem` | 🟡 Stub: vars + delegates | ✅ `08_BPC_HealthSystem.md` | BP child → implement health logic (take/heal damage, death, I_Damageable) → attach to pawn | 🟡 |
-| 09 | `BPC_StaminaSystem` | 🔵 BP-only | ✅ `09_BPC_StaminaSystem.md` | BP child → attach to pawn | 🔵 |
+| 09 | `BPC_StaminaSystem` | 🟡 Stub: vars + delegates | ✅ `09_BPC_StaminaSystem.md` | BP child → implement stamina logic (drain, regen, exhaustion states) → attach to pawn | 🟡 |
-| 10 | `BPC_StressSystem` | 🔵 BP-only | ✅ `10_BPC_StressSystem.md` | BP child → attach to pawn | 🔵 |
+| 10 | `BPC_StressSystem` | 🟡 Stub: enum + vars + delegates | ✅ `10_BPC_StressSystem.md` | BP child → implement stress logic (accumulation, decay, tier transitions) → attach to pawn | 🟡 |
-| 11 | `BPC_MovementStateSystem` | 🔵 BP-only | ✅ `11_BPC_MovementStateSystem.md` | BP child → attach to pawn | 🔵 |
+| 11 | `BPC_MovementStateSystem` | 🟡 Stub: vars + delegates | ✅ `11_BPC_MovementStateSystem.md` | BP child → implement movement logic (CMC reads, GASP bridge, posture detection) → attach to pawn | 🟡 |
 | 12 | `BPC_HidingSystem` | 🔵 BP-only | ✅ `12_BPC_HidingSystem.md` | BP child → attach to pawn | 🔵 |
 | 13 | `BPC_EmbodimentSystem` | 🔵 BP-only | ✅ `13_BPC_EmbodimentSystem.md` | BP child → attach to pawn | 🔵 |
 | 14 | `BPC_CameraStateLayer` | 🔵 BP-only | ✅ `14_BPC_CameraStateLayer.md` | BP child → attach to pawn | 🔵 |
 | 15 | `BPC_PlayerMetricsTracker` | 🔵 BP-only | ✅ `15_BPC_PlayerMetricsTracker.md` | BP child → attach to pawn | 🔵 |
 | — | `PC_CoreController` | 🟡 Stub: minimal empty class | ✅ (covered in 02-player integration) | **BP child** `PC_CoreController` → add input routing, BeginPlay push IMC | 🟡 |
 | — | `PS_CorePlayerState` | 🟡 Stub: minimal empty class | ✅ (covered in 02-player integration) | **BP child** `PS_CorePlayerState` → add replicated state variables | 🟡 |
 ---
@@ -146,14 +153,14 @@ Abbreviations:
 | 69 | `BP_WeaponBase` | 🔵 | ✅ | BP actor child |
 | 70 | `BPC_AmmoComponent` | 🔵 | ✅ | BP child |
 | 71 | `BPC_CombatFeedbackComponent` | 🔵 | ✅ | BP child |
-| 72 | `BPC_DamageReceptionSystem` | ✅ `Weapons/BPC_DamageReceptionSystem` | ✅ | None (use C++ component) |
+| 72 | `BPC_DamageReceptionSystem` | ✅ Full — `Weapons/BPC_DamageReceptionSystem` | ✅ | None (attach C++ component directly) |
 | 73 | `BPC_DeathCauseTracker` | 🔵 | ✅ | BP child |
 | 74 | `BPC_FirearmSystem` | 🔵 | ✅ | BP child |
-| 75 | `BPC_HitReactionSystem` | 🔵 | ✅ | BP child |
+| 75 | `BPC_HitReactionSystem` | 🟡 Stub: `PlayHitReaction()` + thresholds | ✅ | BP child → add animation selection/trigger logic → attach to pawn/enemy |
 | 76 | `BPC_MeleeSystem` | 🔵 | ✅ | BP child |
 | 77 | `BPC_RecoilSystem` | 🔵 | ✅ | BP child |
 | 78 | `BPC_ReloadSystem` | 🔵 | ✅ | BP child |
-| 79 | `BPC_ShieldDefenseSystem` | 🔵 | ✅ | BP child |
+| 79 | `BPC_ShieldDefenseSystem` | 🟡 Stub: shield health + block angle vars | ✅ | BP child → add raise/lower/block detection → attach to pawn |
 ### AI (09-ai — 9 systems)
@@ -179,57 +186,113 @@ Abbreviations:
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
-| 115-127, 129, 134-135 | All 16 systems | 🔵 | ✅ | ⬜ Data Asset instances (per content item) |
+| 115 | `DA_AdaptationRule` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 116 | `DA_AtmosphereProfile` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 117 | `DA_BehaviourVariant` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 118 | `DA_DataAssetArchitecture` | 🔵 | ✅ | Reference doc only |
 | 119 | `DA_EncounterData` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 120 | `DA_EquipmentConfig` | 🟡 Stub: damage resist struct + `GetResistance()` | ✅ | ⬜ Data Asset instances per equipment piece |
 | 121 | `DA_HapticProfile` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 122 | `DA_InteractionData` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 123 | `DA_ObjectiveData` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 124 | `DA_PuzzleData` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 125 | `DA_RareEvent` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 126 | `DA_RoomMutation` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 127 | `DA_ScareEvent` | 🔵 | ✅ | ⬜ Data Asset instances |
 | 129 | `DA_InputMappingProfile` | 🔵 | ✅ | ⬜ Data Asset instances (per platform: PC/Xbox/PS5) |
 | 134 | `DA_AudioSettings` | 🔵 | ✅ | ⬜ Data Asset instance (1 global) |
 | 135 | `DA_RoomAcousticPreset` | 🔵 | ✅ | ⬜ Data Asset instances (per zone) |
 ### Input + State (15-16 — 3 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
-| 128 | `SS_EnhancedInputManager` | ✅ `Input/SS_EnhancedInputManager` | ✅ | None (auto-created subsystem) |
+| 128 | `SS_EnhancedInputManager` | ✅ Full — `Input/SS_EnhancedInputManager` | ✅ | None (auto-created subsystem) |
-| 130 | `BPC_StateManager` | ✅ `Player/BPC_StateManager` | ✅ | None (use C++ component) |
+| 130 | `BPC_StateManager` | ✅ Full — `Player/BPC_StateManager` | ✅ | None (attach C++ component directly to pawn) |
-| 131 | `DA_StateGatingTable` | 🔵 | ✅ | ⬜ Data Asset instance (37 rules) |
+| 131 | `DA_StateGatingTable` | 🟡 Stub: `FStateGatingRule` struct + `IsActionGated()` query | ✅ | ⬜ Data Asset instance (37 gating rules) |
 ---
 ## Summary Counts
 | Category | Count |
 |----------|-------|
 | **C++ systems written** | 12 |
 | **BP spec files complete** | 135 + 1 starter = 136 |
 | **BP components to create** | 76 (80 BPC_ total − 4 C++) |
 | **BP actors to create** | 11 |
 | **Widget BPs to create** | 14 |
 | **Data Asset instances to create** | Per-project (18 DA_ definitions) |
 | **GameInstance subsystems** (auto-created) | 7 (3 in C++, 4 BP) |
 | **Data Tables to create** | 11 |
 ---
 ## Quick Action List — What to Build Next
 ### Immediate (Phase 0 — Foundation)
- [ ] Create 11 Data Tables, import CSVs, register in Project Settings
+- [ ] Create 11 Data Tables from CSV, import, register in Project Settings
- [ ] Create `DA_GameTagRegistry` Data Asset, assign TagDataTables
+- [ ] Create `DA_GameTagRegistry` Data Asset, assign TagDataTables array (11 entries)
 - [ ] Create `BP_GameFramework` (child of `GI_GameFramework`), assign TagRegistry
- [ ] Create `BP_CoreGameMode` (child of `GM_CoreGameMode`), set in Project Settings
+- [ ] Create `BP_CoreGameMode` (child of `GM_CoreGameMode`), set classes in defaults
- [ ] Create `BP_CoreGameState` (child of `GS_CoreGameState`), set in GameMode defaults
+- [ ] Create `BP_CoreGameState` (child of `GS_CoreGameState`)
- [ ] Create `BP_CorePlayerController` + `BP_CorePlayerState` (BP specs 08 area)
+- [ ] Create `PC_CoreController` + `PS_CorePlayerState` BP children (C++ stub parents)
- [ ] Create `DA_ItemData` instances for initial items (weapons, consumables)
+- [ ] Create 22 IA_* Input Actions + 5 IMC_* Input Mapping Contexts
 - [ ] Create `DA_InputMappingProfile` instances (PC/Xbox/PS5)
 ### Player Pawn Setup
- [ ] Create player pawn BP with GASP
+- [ ] Create player pawn BP (Character parent) with basic movement
- [ ] Add `BPC_StateManager` component → assign GatingTable
+- [ ] Add `BPC_StateManager` component → assign `DA_StateGatingTable`
- [ ] Add `BPC_InventorySystem` component → set grid size
+- [ ] Add `BPC_HealthSystem` (C++ stub) → implement health logic in BP child
- [ ] Add `BPC_DamageReceptionSystem` component → set thresholds
+- [ ] Add `BPC_StaminaSystem` (C++ stub) → implement stamina logic
- [ ] Add remaining 76 `BPC_*` BP children as needed
+- [ ] Add `BPC_StressSystem` (C++ stub) → implement stress logic
 - [ ] Add `BPC_MovementStateSystem` (C++ stub) → implement movement bridge
 - [ ] Add `BPC_InventorySystem` (C++ full) → set grid size + max weight
 - [ ] Add `BPC_DamageReceptionSystem` (C++ full) → set thresholds
 - [ ] Add `BPC_ShieldDefenseSystem` (C++ stub) → implement shield logic
 - [ ] Add `BPC_HitReactionSystem` (C++ stub) → implement hit reaction animations
 - [ ] Add remaining 55 `BPC_*` BP children as needed (see build order doc)
 ### State Management
 - [ ] Create `E_PlayerActionState` enum (42 values) in editor
 - [ ] Create `E_OverlayState` enum (18 values) in editor
 - [ ] Create `E_ActionRequestResult` enum (8 values) in editor
 - [ ] Create `E_PlayerVitalSignals` enum (5 values) in editor
 - [ ] Create `S_StateChangeRequest`, `S_StateGatingRule`, `S_ActionPermissionResult` structs
 - [ ] Create `DA_StateGatingTable` instance → populate 37 gating rules
 ### Data Asset Content
- [ ] Create `DA_StateGatingTable` instance with 37 rules
+- [ ] Create `DA_Item_*` instances for test items (medkit, key, etc.)
- [ ] Create `DA_EquipmentConfig` instance(s) for armor/weapons
+- [ ] Create `DA_Equipment_*` instances for armor/weapons
 - [ ] Create `DA_AudioSettings`, `DA_RoomAcousticPreset` instances
 - [ ] Create remaining `DA_*` instances per project content
 ### Prototype Testing
 - [ ] Follow [`docs/developer/project-prototype-guide.md`](../developer/project-prototype-guide.md) for step-by-step setup
 - [ ] Run the [Verification Checklist](../developer/project-prototype-guide.md#10-verification-checklist)
 - [ ] Expand per the [Next Steps](../developer/project-prototype-guide.md#11-next-steps--expanding-the-prototype)
 ---
-*Status Checklist v1.0 — Updated 2026-05-20. Regenerate after each implementation phase.*
+## C++ Source File Index
 ### Full Implementations (12 systems — logic complete, no BP child needed for functionality)
 | # | C++ Class | Header | Source | Size |
 |---|-----------|--------|--------|------|
 | 01 | `UDA_GameTagRegistry` | `Public/Core/DA_GameTagRegistry.h` | `Private/Core/DA_GameTagRegistry.cpp` | 105 + cpp |
 | 02 | `UFL_GameUtilities` | `Public/Core/FL_GameUtilities.h` | `Private/Core/FL_GameUtilities.cpp` | 169 + cpp |
 | 03 | 9 `I_` Interfaces | `Public/Core/I_InterfaceLibrary.h` | — | 317 (header-only) |
 | 04 | `UGI_GameFramework` | `Public/Core/GI_GameFramework.h` | `Private/Core/GI_GameFramework.cpp` | 226 + cpp |
 | 05 | `AGM_CoreGameMode` | `Public/Core/GM_CoreGameMode.h` | `Private/Core/GM_CoreGameMode.cpp` | 116 + cpp |
 | 06 | `AGS_CoreGameState` | `Public/Core/GS_CoreGameState.h` | `Private/Core/GS_CoreGameState.cpp` | 144 + cpp |
 | 07 | `UDA_ItemData` | `Public/Inventory/DA_ItemData.h` | `Private/Inventory/DA_ItemData.cpp` | 232 + cpp |
 | 31 | `UBPC_InventorySystem` | `Public/Inventory/BPC_InventorySystem.h` | `Private/Inventory/BPC_InventorySystem.cpp` | 210 + cpp |
 | 35 | `USS_SaveManager` | `Public/Save/SS_SaveManager.h` | `Private/Save/SS_SaveManager.cpp` | 193 + cpp |
 | 72 | `UBPC_DamageReceptionSystem` | `Public/Weapons/BPC_DamageReceptionSystem.h` | `Private/Weapons/BPC_DamageReceptionSystem.cpp` | 150 + cpp |
 | 128 | `USS_EnhancedInputManager` | `Public/Input/SS_EnhancedInputManager.h` | `Private/Input/SS_EnhancedInputManager.cpp` | 232 + cpp |
 | 130 | `UBPC_StateManager` | `Public/Player/BPC_StateManager.h` | `Private/Player/BPC_StateManager.cpp` | 246 + cpp |
 ### C++ Stubs (10 systems — UCLASS + basic vars/delegates, need BP child for logic)
 | # | C++ Class | Header | Source | Purpose |
 |---|-----------|--------|--------|---------|
 | 08 | `UBPC_HealthSystem` | `Public/Player/BPC_HealthSystem.h` | `Private/Player/BPC_HealthSystem.cpp` | Health vars + delegates |
 | 09 | `UBPC_StaminaSystem` | `Public/Player/BPC_StaminaSystem.h` | `Private/Player/BPC_StaminaSystem.cpp` | Stamina vars + delegate |
 | 10 | `UBPC_StressSystem` | `Public/Player/BPC_StressSystem.h` | `Private/Player/BPC_StressSystem.cpp` | Stress enum + vars + delegate |
 | 11 | `UBPC_MovementStateSystem` | `Public/Player/BPC_MovementStateSystem.h` | `Private/Player/BPC_MovementStateSystem.cpp` | Movement vars + delegate |
 | — | `APC_CoreController` | `Public/Player/PC_CoreController.h` | `Private/Player/PC_CoreController.cpp` | Minimal controller stub |
 | — | `APS_CorePlayerState` | `Public/Player/PS_CorePlayerState.h` | `Private/Player/PS_CorePlayerState.cpp` | Minimal player state stub |
 | 75 | `UBPC_HitReactionSystem` | `Public/Weapons/BPC_HitReactionSystem.h` | `Private/Weapons/BPC_HitReactionSystem.cpp` | Hit reaction stub |
 | 79 | `UBPC_ShieldDefenseSystem` | `Public/Weapons/BPC_ShieldDefenseSystem.h` | `Private/Weapons/BPC_ShieldDefenseSystem.cpp` | Shield defense stub |
 | 120 | `UDA_EquipmentConfig` | `Public/Inventory/DA_EquipmentConfig.h` | `Private/Inventory/DA_EquipmentConfig.cpp` | Equipment config stub |
 | 131 | `UDA_StateGatingTable` | `Public/State/DA_StateGatingTable.h` | `Private/State/DA_StateGatingTable.cpp` | Gating table stub |
 ---
 *Status Checklist v2.0 — Updated 2026-05-21. See [`remaining-blueprint-build-order.md`](remaining-blueprint-build-order.md) for the prioritized build list.*
--- a/docs/checklists/remaining-blueprint-build-order.md
+++ b/docs/checklists/remaining-blueprint-build-order.md
@@ -0,0 +1,673 @@
 # Remaining Blueprint Build Order — All 135 Systems
 **Version:** 1.0 | **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:** `Content/Framework/Core/DA_GameTagRegistry` → assign `TagDataTables` (11 entries) |
 | **Manual Steps** | 11 Data Tables must be created from CSV and registered in Project Settings first. |
 ### 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`). In Class Defaults: set `TagRegistry` → `DA_GameTagRegistry`, `bValidateTagsOnInit` → `true`. |
 | **Project Settings** | Set as **Default Game Instance** in Maps & Modes. |
 ### 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`). In Class Defaults: set `PlayerControllerClass` → `PC_CoreController`, `PlayerStateClass` → `PS_CorePlayerState`, `GameStateClass` → `BP_CoreGameState`, `DefaultPawnClass` → your player pawn. |
 | **Project Settings** | Set as **Default GameMode** in Maps & Modes. |
 ### 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`). No extra config needed — replicated state works out of the box. |
 ### 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:** `DA_Item_*` per game item (weapons, consumables, key items, documents, collectibles, tools, resources, misc). |
 ### 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`). Add logic: input routing, BeginPlay (push IMC_Default), phase handling. |
 ### — 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`). Add player-specific replicated state: inventory slots, equipped items, narrative flags. |
 ### 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 |
 ### 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. Set `DA_ItemData` per instance. |
 ### 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. Set `GridWidth`, `GridHeight`, `MaxWeight` in Details panel. |
 | **Attach To** | Player pawn |
 ### 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 |
 ---
 ## 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)
 ```
 ---
 ## 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/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_)** | 79 | 4 full C++, 8 stubs | 67 BP children (8 have C++ stubs to extend) |
 | **BP Actors (BP_)** | 11 | 0 | 11 BP actor children |
 | **Widget BPs (WBP_)** | 14 | 0 | 14 Widget BPs |
 | **Data Assets (DA_)** | 18 | 3 full C++, 2 stubs | ~200+ DA instances (content-driven) |
 | **GameInstance Subsystems (SS_)** | 7 | 3 full C++ | 4 BP children |
 | **Interfaces (I_)** | 10 | 9 in C++ | 1 (I_HidingSpot) |
 | **Function Libraries (FL_)** | 1 | 1 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.0 — Companion to `cpp-blueprint-status.md` and `cpp-integration-guide.md`.*
--- a/docs/developer/INDEX.md
+++ b/docs/developer/INDEX.md
@@ -1,6 +1,6 @@
 # Developer Reference — UE5 Modular Game Framework
-**Version:** 1.4 | **Generated:** 2026-05-20 | **Files:** 17 (1 index + 2 overview + 1 migration + 1 integration + 1 starter + 10 category docs + 1 combined) | **C++:** 12 systems migrated
+**Version:** 1.5 | **Generated:** 2026-05-21 | **Files:** 18 (1 index + 2 overview + 1 migration + 1 integration + 1 prototype + 1 starter + 10 category docs + 1 combined) | **C++:** 12 full + 10 stubs = 22 systems
 This directory contains developer-facing reference documentation for every system in the framework. Unlike the blueprint spec files (which define *what* to build), these documents explain *how each system works internally* — the data flow, state machines, integration points, and design rationale. Use these when you need to understand a system's behavior to implement, debug, or extend it.
@@ -18,9 +18,11 @@ docs/developer/
 ├── INDEX.md                              ← THIS FILE
 ├── architecture-overview.md              ← Framework-wide architecture walkthrough
 ├── implementation-patterns.md            ← Common UE5 Blueprint patterns used
-├── cpp-integration-guide.md              ← C++ per-system integration & setup (NEW — 12 systems)
+├── cpp-integration-guide.md              ← C++ per-system integration & setup (22 systems)
 ├── project-setup-migration.md            ← Project setup & migration guide
 ├── project-prototype-guide.md            ← Step-by-step prototype build guide (NEW)
 ├── 00-starter-gameinstance.md            ← Starter GameInstance: GI_StarterGameInstance setup guide
 ├── 01-core-foundation.md                 ← Foundation systems explained
 ├── 02-player-systems.md                  ← Player state & embodiment (systems 08-15)
 ├── 03-interaction-systems.md             ← Interaction & world manipulation (systems 16-23)
 ├── 04-inventory-systems.md               ← Inventory, items & collectibles (systems 24-34)
@@ -178,12 +180,14 @@ docs/developer/
 1. **New to the framework?** Start with [`architecture-overview.md`](architecture-overview.md) to understand the big picture.
 2. **Setting up a new project?** Read [`00-starter-gameinstance.md`](00-starter-gameinstance.md) first — create `GI_StarterGameInstance` to validate your GameplayTags immediately. Then follow [`project-setup-migration.md`](project-setup-migration.md) for full Project Settings, plugins, Data Tables, and init sequence.
-3. **Using the C++ classes?** Read [`cpp-integration-guide.md`](cpp-integration-guide.md) — per-system setup steps, Blueprint children to create, usage patterns, and build order. See [`../checklists/cpp-blueprint-status.md`](../checklists/cpp-blueprint-status.md) for the full 135-system status grid.
+3. **Building a prototype?** Follow [`project-prototype-guide.md`](project-prototype-guide.md) — step-by-step instructions from blank project to working test character with verification checklist.
-4. **Implementing a system?** Read the Blueprint Spec in `docs/blueprints/` — every file has a Manual Implementation Guide with node-by-node logic.
+4. **Using the C++ classes?** Read [`cpp-integration-guide.md`](cpp-integration-guide.md) — per-system setup steps, Blueprint children to create, usage patterns, and build order. See [`../checklists/cpp-blueprint-status.md`](../checklists/cpp-blueprint-status.md) for the full 135-system status grid.
-5. **Need to understand internals?** Read the corresponding Developer Reference doc in this directory.
+5. **Need the prioritized BP build list?** See [`../checklists/remaining-blueprint-build-order.md`](../checklists/remaining-blueprint-build-order.md) — every system with C++ status, what BP to build, and dependency-safe order.
-6. **Debugging?** Each category doc includes a data flow section showing how data moves between systems.
+6. **Implementing a system?** Read the Blueprint Spec in `docs/blueprints/` — every file has a Manual Implementation Guide with node-by-node logic.
-7. **Need UE5 Blueprint patterns?** See [`implementation-patterns.md`](implementation-patterns.md).
+7. **Need to understand internals?** Read the corresponding Developer Reference doc in this directory.
-8. **Multiplayer networking?** See [`../architecture/multiplayer-networking.md`](../architecture/multiplayer-networking.md). Every doc has a Multiplayer Networking section.
+8. **Debugging?** Each category doc includes a data flow section showing how data moves between systems.
 9. **Need UE5 Blueprint patterns?** See [`implementation-patterns.md`](implementation-patterns.md).
 10. **Multiplayer networking?** See [`../architecture/multiplayer-networking.md`](../architecture/multiplayer-networking.md). Every doc has a Multiplayer Networking section.
 ## Relationship to Spec Files
--- a/docs/developer/project-prototype-guide.md
+++ b/docs/developer/project-prototype-guide.md
@@ -0,0 +1,713 @@
 # Project Prototype Guide — PG_Framework Testing Setup
 **Version:** 1.0 | **Target UE:** 5.5–5.7 | **C++ Module:** PG_Framework
 This guide walks you through creating a minimal playable prototype in UE5 that tests the PG_Framework C++ source. By the end, you'll have a character that can move, take damage, manage inventory, and respond to state gating — all powered by the framework's C++ classes.
 **Goal:** A working prototype you can expand with additional Blueprint components.
 **Time estimate:** 2-4 hours for a developer familiar with UE5.
 ---
 ## Table of Contents
 1. [Project Creation](#1-project-creation)
 2. [C++ Module Integration](#2-c-module-integration)
 3. [Gameplay Tags Setup](#3-gameplay-tags-setup)
 4. [Foundation Blueprint Assets](#4-foundation-blueprint-assets)
 5. [Player Pawn Assembly](#5-player-pawn-assembly)
 6. [Input System Setup](#6-input-system-setup)
 7. [State Management Wiring](#7-state-management-wiring)
 8. [Test Level Setup](#8-test-level-setup)
 9. [Data Asset Content](#9-data-asset-content)
 10. [Verification Checklist](#10-verification-checklist)
 11. [Next Steps — Expanding the Prototype](#11-next-steps--expanding-the-prototype)
 12. [Troubleshooting](#12-troubleshooting)
 ---
 ## 1. Project Creation
 ### 1.1 Create New Project
 1. Launch **UE5.5+** → **Games** → **Blank (C++)**
 2. Project Name: `PG_Prototype` (or your choice)
 3. Location: Anywhere outside the PG_Framework workspace
 4. **Disable** Starter Content (we use framework assets)
 5. **Enable** Raytracing: No (unless you need it)
 6. Target Platform: Desktop
 7. Quality Preset: Scalable
 ### 1.2 Enable Required Plugins
 After the project opens:
 1. `Edit → Plugins`
 2. Search and enable:
   - ✅ **Enhanced Input** (Input category)
   - ✅ **GameplayTags** (should be on by default)
   - ✅ **Motion Warping** (Animation category — needed for traversal later)
 3. Restart Editor when prompted.
 ### 1.3 Close the Editor
 We need to add the PG_Framework module. Keep the project folder open in Explorer.
 ---
 ## 2. C++ Module Integration
 ### 2.1 Copy Source Files
 Copy the entire `Source/PG_Framework/` directory from your PG_Framework workspace into your prototype project:
 ```
 PG_Prototype/
 ├── Source/
 │   ├── PG_Prototype/          ← Your project's module (keep)
 │   ├── PG_Framework/          ← COPY from PG_Framework workspace
 │   │   ├── PG_Framework.Build.cs
 │   │   ├── PG_Framework.Target.cs
 │   │   ├── PG_FrameworkEditor.Target.cs
 │   │   ├── PG_Framework.h
 │   │   ├── PG_Framework.cpp
 │   │   ├── Public/
 │   │   │   ├── Core/          (GI_GameFramework, GM_CoreGameMode, etc.)
 │   │   │   ├── Player/        (BPC_HealthSystem, BPC_StateManager, etc.)
 │   │   │   ├── Inventory/     (BPC_InventorySystem, DA_ItemData, etc.)
 │   │   │   ├── Weapons/       (BPC_DamageReceptionSystem, etc.)
 │   │   │   ├── Save/          (SS_SaveManager)
 │   │   │   ├── Input/         (SS_EnhancedInputManager)
 │   │   │   └── State/         (DA_StateGatingTable)
 │   │   └── Private/
 │   │       └── ...            (mirrors Public/ structure)
 │   └── PG_PrototypeEditor.Target.cs
 ```
 ### 2.2 Add Module Dependency
 Edit `Source/PG_Prototype/PG_Prototype.Build.cs`:
 ```csharp
 // Find the PublicDependencyModuleNames array and add:
 PublicDependencyModuleNames.AddRange(new string[] {
    "Core",
    "CoreUObject",
    "Engine",
    "InputCore",
    "EnhancedInput",      // Required by SS_EnhancedInputManager
    "GameplayTags",       // Required by all framework systems
    "PG_Framework"        // ← ADD THIS LINE
 });
 ```
 ### 2.3 Register Module in Target
 Edit `Source/PG_Prototype.Target.cs`:
 ```csharp
 ExtraModuleNames.AddRange(new string[] {
    "PG_Prototype",
    "PG_Framework"     // ← ADD THIS LINE
 });
 ```
 ### 2.4 Build
 1. Right-click `PG_Prototype.uproject` → **Generate Visual Studio project files**
 2. Open the `.sln` in your IDE, or right-click `.uproject` → **Switch Unreal Engine Version** if needed
 3. Build from IDE, or open the project and let UE5 compile
 If you get compile errors about missing includes, ensure `EnhancedInput` and `GameplayTags` are in the `PublicDependencyModuleNames` of `PG_Framework.Build.cs` (they should already be):
 ```csharp
 // PG_Framework.Build.cs should contain:
 PublicDependencyModuleNames.AddRange(new string[] {
    "Core",
    "CoreUObject",
    "Engine",
    "EnhancedInput",
    "GameplayTags",
    "InputCore"
 });
 ```
 ### 2.5 Verify Compilation
 After the project opens, check `Window → Developer Tools → Modules` and confirm `PG_Framework` appears as loaded.
 ---
 ## 3. Gameplay Tags Setup
 ### 3.1 Create Data Table Assets from CSV
 For each CSV file in `docs/blueprints/01-core/data-tables/`, create a Data Table asset:
 1. `Content Browser → Framework/DataTables/` (create folder if needed)
 2. Right-click → **Miscellaneous → Data Table**
 3. Row Structure: `GameplayTagTableRow`
 4. Name: `DT_Tags_[Category]` (e.g., `DT_Tags_Player`)
 5. Open the Data Table → **Import** → select the corresponding CSV
 Repeat for all 11:
 | File | Data Table Name |
 |------|----------------|
 | `DT_Tags_Player.csv` | `DT_Tags_Player` |
 | `DT_Tags_Interaction.csv` | `DT_Tags_Interaction` |
 | `DT_Tags_Item.csv` | `DT_Tags_Item` |
 | `DT_Tags_Narrative.csv` | `DT_Tags_Narrative` |
 | `DT_Tags_AI.csv` | `DT_Tags_AI` |
 | `DT_Tags_Save.csv` | `DT_Tags_Save` |
 | `DT_Tags_Environment.csv` | `DT_Tags_Environment` |
 | `DT_Tags_Combat.csv` | `DT_Tags_Combat` |
 | `DT_Tags_State.csv` | `DT_Tags_State` |
 | `DT_Tags_Audio.csv` | `DT_Tags_Audio` |
 | `DT_Tags_Achievement.csv` | `DT_Tags_Achievement` |
 ### 3.2 Register Data Tables in Project Settings
 1. `Edit → Project Settings → Gameplay Tags`
 2. Under **Gameplay Tag Table List**, click `+` eleven times
 3. For each entry, click the dropdown and select one of the 11 `DT_Tags_*` tables
 4. **Click the refresh icon** next to "Import Tags from Config" to force tag load
 5. Verify: Type `Framework.Player.State.Alive` in the search bar at the bottom → it should appear as a valid tag
 > **⚠️ Without this step**, no gameplay tags work. Framework tags will be invalid.
 ---
 ## 4. Foundation Blueprint Assets
 ### 4.1 Create DA_GameTagRegistry Data Asset
 1. `Content Browser → Framework/Core/`
 2. Right-click → **Miscellaneous → Data Asset**
 3. Class: `DA_GameTagRegistry`
 4. Name: `DA_GameTagRegistry`
 5. Open it → assign the `Tag Data Tables` array:
   - Click `+` 11 times
   - Add each of the 11 `DT_Tags_*` Data Tables
 6. Save
 ### 4.2 Create BP_GameFramework (GameInstance)
 1. `Content Browser → Framework/Core/`
 2. Right-click → **Blueprint Class**
 3. Parent: `GI_GameFramework`
 4. Name: `BP_GameFramework`
 5. Open it → **Class Defaults**:
   - `Tag Registry` → `DA_GameTagRegistry`
   - `bValidateTagsOnInit` → `true`
   - `bLogTagsOnInit` → `true` (useful for debugging first boot)
 6. Compile → Save
 ### 4.3 Create PC_CoreController and PS_CorePlayerState
 1. Create Blueprint Class → Parent: `APC_CoreController` → name: `PC_CoreController`
 2. Create Blueprint Class → Parent: `APS_CorePlayerState` → name: `PS_CorePlayerState`
 3. Save both to `Content/Framework/Player/`
 These are C++ stubs. For the prototype, they can be empty — expand later with input routing and replicated state.
 ### 4.4 Create BP_CoreGameState
 1. Create Blueprint Class → Parent: `AGS_CoreGameState` → name: `BP_CoreGameState`
 2. Save to `Content/Framework/Core/`
 3. No extra config — all state is replicated automatically.
 ### 4.5 Create BP_CoreGameMode
 1. Create Blueprint Class → Parent: `AGM_CoreGameMode` → name: `BP_CoreGameMode`
 2. Save to `Content/Framework/Core/`
 3. Open → **Class Defaults**:
   - `Game State Class` → `BP_CoreGameState`
   - `Player Controller Class` → `PC_CoreController`
   - `Player State Class` → `PS_CorePlayerState`
   - `Default Pawn Class` → (leave empty for now — we'll set it after creating the player pawn)
 4. Compile → Save
 ### 4.6 Set Project Defaults
 `Edit → Project Settings → Maps & Modes`:
 | Setting | Value |
 |---------|-------|
 | Default GameMode | `BP_CoreGameMode` |
 | Game Instance Class | `BP_GameFramework` |
 | Editor Startup Map | Your test level (create later) |
 | Game Default Map | Your test level |
 ---
 ## 5. Player Pawn Assembly
 ### 5.1 Create Player Pawn Blueprint
 1. `Content Browser → Framework/Player/`
 2. Right-click → **Blueprint Class**
 3. Parent: `Character`
 4. Name: `BP_PlayerCharacter`
 5. Open the Blueprint
 ### 5.2 Attach Required Components
 In the Components panel of `BP_PlayerCharacter`, add these in order:
 **Tier 1 — State & Core (must load first):**
 | Order | Component Class | Variable Name |
 |-------|----------------|---------------|
 | 1 | **BPC_StateManager** | `StateManager` |
 | 2 | **BPC_HealthSystem** | `HealthSystem` |
 | 3 | **BPC_StaminaSystem** | `StaminaSystem` |
 | 4 | **BPC_StressSystem** | `StressSystem` |
 | 5 | **BPC_MovementStateSystem** | `MovementStateSystem` |
 | 6 | **BPC_InventorySystem** | `InventorySystem` |
 **Tier 2 — Combat:**
 | 7 | **BPC_DamageReceptionSystem** | `DamageReceptionSystem` |
 | 8 | **BPC_ShieldDefenseSystem** | `ShieldDefenseSystem` |
 | 9 | **BPC_HitReactionSystem** | `HitReactionSystem` |
 **Tier 3 — Interaction (add as needed):**
 | 10 | **BPC_InteractionDetector** | (create BP child from spec #16 later) |
 | 11 | **BPC_HidingSystem** | (create BP child from spec #12 later) |
 ### 5.3 Configure Component Defaults
 Select each component in the Components panel and set its defaults:
 **State Manager:**
 - `Gating Table` → (will assign DA_StateGatingTable — create it in Step 7 first)
 - `Default Action State` → `Framework.State.Action.Idle`
 - `Default Overlay State` → (leave empty)
 - `Heart Rate Smooth Speed` → `2.0`
 **Health System:**
 - `Max Health` → `100.0`
 **Stamina System:**
 - `Max Stamina` → `100.0`
 **Stress System:**
 - `Stress Tier` → `Calm`
 **Inventory System:**
 - `Grid Width` → `8`
 - `Grid Height` → `5`
 - `Max Weight` → `50.0`
 **Damage Reception System:**
 - `Base Resistance` → `0.0`
 - `Stagger Threshold` → `20.0`
 - `Knockdown Threshold` → `50.0`
 ### 5.4 Create Player Pawn Blueprint (GASP-Free Baseline)
 For the prototype you can use the default UE5 `CharacterMovementComponent` — no GASP needed:
 1. Compile `BP_PlayerCharacter`
 2. The default CharacterMovement settings are fine for testing
 ### 5.5 Assign Pawn to GameMode
 1. Open `BP_CoreGameMode` → Class Defaults
 2. `Default Pawn Class` → `BP_PlayerCharacter`
 3. Save
 ---
 ## 6. Input System Setup
 ### 6.1 Create Input Action Assets
 `Content Browser → Framework/Input/Actions/` (create folders)
 Right-click → **Input → Input Action**, create these minimum actions for the prototype:
 | Input Action | Value Type | Purpose |
 |-------------|-----------|---------|
 | `IA_Move` | Axis2D (Vector2D) | WASD movement |
 | `IA_Look` | Axis2D (Vector2D) | Mouse look |
 | `IA_Jump` | Digital (bool) | Jump |
 | `IA_Sprint` | Digital (bool) | Sprint (stamina drain) |
 | `IA_Interact` | Digital (bool) | Interaction (E key) |
 | `IA_Fire` | Digital (bool) | Weapon fire (testing damage) |
 | `IA_Inventory` | Digital (bool) | Inventory toggle |
 | `IA_Pause` | Digital (bool) | Pause menu |
 ### 6.2 Create Input Mapping Context
 `Content Browser → Framework/Input/Contexts/`
 Right-click → **Input → Input Mapping Context**, name: `IMC_Default`
 Add mappings:
 | Input Action | Key Binding | Triggers |
 |-------------|-------------|----------|
 | `IA_Move` | W, A, S, D (2D axis: W=Y+, S=Y-, D=X+, A=X-) | Down trigger |
 | `IA_Look` | Mouse XY 2D Axis | Down trigger |
 | `IA_Jump` | Space Bar | Pressed trigger |
 | `IA_Sprint` | Left Shift | Pressed + Released triggers |
 | `IA_Interact` | E | Pressed trigger |
 | `IA_Fire` | Left Mouse Button | Pressed trigger |
 | `IA_Inventory` | Tab | Pressed trigger |
 | `IA_Pause` | Escape | Pressed trigger |
 ### 6.3 Wire Input in PC_CoreController
 Open `PC_CoreController` Blueprint → **Event Graph**:
 ```
 Event BeginPlay
  → Get Game Instance → Cast To BP_GameFramework
  → Get Subsystem (Class: SS_EnhancedInputManager) [if not auto-created, use GetSubsystemSafe]
  → Push Context (IMC_Default, Priority: 0, Tag: Framework.Input.Context.Default)
 ```
 > **Note:** `SS_EnhancedInputManager` is auto-created by UE. At `BeginPlay`, call `GetSubsystem<USS_EnhancedInputManager>()` from the GameInstance and push `IMC_Default`.
 ### 6.4 Wire Movement in PlayerCharacter
 Open `BP_PlayerCharacter` → **Event Graph**:
 ```
 Event Setup Player Input Component
  → Get Enhanced Input Local Player Subsystem (from PlayerController)
  → Bind Action (IA_Move, Triggered → call "Add Movement Input" using ActionValue)
  → Bind Action (IA_Look, Triggered → call "Add Controller Yaw/Pitch Input")
  → Bind Action (IA_Jump, Started → call "Jump")
  → Bind Action (IA_Jump, Completed → call "Stop Jumping")
 ```
 Basic movement setup — see the Enhanced Input documentation for details.
 ---
 ## 7. State Management Wiring
 ### 7.1 Create DA_StateGatingTable
 1. `Content Browser → Framework/State/`
 2. Right-click → **Miscellaneous → Data Asset**
 3. Class: `DA_StateGatingTable`
 4. Name: `DA_StateGatingTable`
 5. Open → populate `Gating Rules` array with rules.
 **Minimum rules for prototype:**
 | # | Action Tag | Blocked By State | Is Blocked? |
 |---|-----------|-----------------|-------------|
 | 1 | `Framework.Action.Sprint` | `Framework.State.Action.Dead` | ✅ true |
 | 2 | `Framework.Action.Sprint` | `Framework.State.Action.Hiding` | ✅ true |
 | 3 | `Framework.Action.Jump` | `Framework.State.Action.Dead` | ✅ true |
 | 4 | `Framework.Action.Interact` | `Framework.State.Action.Dead` | ✅ true |
 | 5 | `Framework.Action.FireWeapon` | `Framework.State.Action.Dead` | ✅ true |
 | 6 | `Framework.Action.FireWeapon` | `Framework.State.Action.Hiding` | ✅ true |
 | 7 | `Framework.Action.Reload` | `Framework.State.Action.Dead` | ✅ true |
 | 8 | `Framework.Action.UseItem` | `Framework.State.Action.Dead` | ✅ true |
 > Full 37-rule table: see `docs/architecture/bpc-statemanager.md` Section 9.
 ### 7.2 Assign Gating Table
 1. Open `BP_PlayerCharacter`
 2. Select `StateManager` component
 3. `Gating Table` → `DA_StateGatingTable`
 4. Compile → Save
 ### 7.3 Create State Manager Enums & Structs
 In `Content/Framework/State/`:
 **Enum: E_PlayerActionState** (42 values)
 ```
 Idle, Moving, Sprinting, Crouching, Prone, Jumping, Falling, Landing,
 Swimming, Climbing, Vaulting, Mantling, Sliding, Squeezing,
 Interacting, Inspecting, UsingItem, Equipping, PickingUp,
 Hiding, Peeking, HoldingBreath,
 Attacking, Aiming, Firing, Reloading, Blocking, Throwing,
 Staggered, KnockedDown, Dead, Respawning,
 InCutscene, InDialogue, InMenu,
 Pushing, Pulling, Dragging,
 Stunned, Frozen, Trapped, Carrying
 ```
 **Enum: E_OverlayState** (18 values)
 ```
 None, AimingDownSights, Reloading, Inspecting, UsingItem,
 Flashlight, Wristwatch, Map, Radio, Compass,
 HoldingWeapon, HoldingTool, HoldingThrowable,
 CarryingObject, InjuredLeftArm, InjuredRightArm,
 TalkingOnRadio, ReadingDocument
 ```
 **Enum: E_ActionRequestResult** (8 values)
 ```
 Granted, Denied, BlockedByForce, AlreadyActive,
 InvalidState, RequesterNotFound, CooldownActive, VitalThreshold
 ```
 **Struct: S_StateGatingRule**
 ```
 ActionTag : GameplayTag
 BlockedByState : GameplayTag
 bIsBlocked : Boolean
 ```
 ### 7.4 Verify StateManager at Runtime
 Add this to `BP_PlayerCharacter` BeginPlay:
 ```
 Event BeginPlay
  → Get StateManager component
  → Print String (concat "StateManager Ready. Default: " + Current Action State → ToString)
  → Bind OnActionStateChanged → Print String ("Action state changed: " + NewState)
 ```
 ---
 ## 8. Test Level Setup
 ### 8.1 Create Test Level
 1. `File → New Level → Empty Level`
 2. Save as `Content/Maps/L_PrototypeTest`
 ### 8.2 Place Required Actors
 | Actor | Type | Notes |
 |-------|------|-------|
 | **Player Start** | `PlayerStart` | Drag from Place Actors panel |
 | **Directional Light** | `DirectionalLight` | Default one is fine |
 | **Sky Light** | `SkyLight` | Default one is fine |
 | **Sky Atmosphere** | `SkyAtmosphere` | For realistic sky |
 | **Exponential Height Fog** | `ExponentialHeightFog` | Atmosphere depth |
 | **Floor** | `StaticMesh` → Cube | Scale to X=50, Y=50, Z=0.1 for a ground plane |
 | **Volumetric Clouds** | `VolumetricCloud` | Optional — visual polish |
 ### 8.3 Add Test Objects
 For testing interaction, place a simple cube or a `BP_DoorActor` (create from spec #19):
 1. Place a Static Mesh (Cube) in the level
 2. Scale to represent a door: X=0.2, Y=3, Z=4
 3. For the prototype, just test that interaction raycasts hit it
 ### 8.4 Set as Startup Map
 1. `Edit → Project Settings → Maps & Modes`
 2. `Editor Startup Map` → `L_PrototypeTest`
 3. `Game Default Map` → `L_PrototypeTest`
 ---
 ## 9. Data Asset Content
 ### 9.1 Create Test Items
 In `Content/Framework/DataAssets/Items/`:
 1. Right-click → **Miscellaneous → Data Asset**
 2. Class: `DA_ItemData`
 3. Name: `DA_Item_TestMedKit`
 Set properties:
 | Property | Value |
 |----------|-------|
 | Item Tag | `Framework.Item.Consumable.MedKit` |
 | Display Name | "MedKit" |
 | Description | "A standard medical kit. Restores 25 health." |
 | Weight | 1.0 |
 | Stack Limit | 5 |
 | Item Type | Consumable |
 | Consumable Data → Health Restore | 25.0 |
 | Consumable Data → Use Duration | 2.0 |
 | Consumable Data → Consumed on Use | true |
 Create a second item for testing inventory:
 | Property | Value |
 |----------|-------|
 | Item Tag | `Framework.Item.Key.RustyKey` |
 | Display Name | "Rusty Key" |
 | Description | "An old rusted key. Might open something nearby." |
 | Weight | 0.5 |
 | Stack Limit | 1 |
 | Item Type | Key Item |
 | bIsKeyItem | true |
 ### 9.2 Create DA_EquipmentConfig (for armor testing)
 1. Right-click → **Miscellaneous → Data Asset**
 2. Class: `DA_EquipmentConfig`
 3. Name: `DA_Equipment_DefaultArmor`
 Set:
 | Property | Value |
 |----------|-------|
 | Durability | 100.0 |
 | Weight | 5.0 |
 | Damage Type Resistances | Array[0] → Damage Type: `Framework.Combat.Damage.Physical`, Resistance: 0.2 |
 ### 9.3 Place Item Pickup in Level
 1. Create Blueprint Class → Parent: `BP_ItemPickup` (per spec #25)
 2. Or for quick test: place a simple `StaticMeshActor` with a Cube mesh, add `I_Interactable` interface later
 ---
 ## 10. Verification Checklist
 Run **Play In Editor (PIE)** and verify:
 ### Core Systems
 - [ ] Editor opens without asset-loading errors
 - [ ] `Output Log` shows: "GI_GameFramework: Framework initialized. X tags validated."
 - [ ] `Output Log` shows: "StateManager: Loaded gating table with N rules."
 - [ ] No `GetSubsystem()` null pointer errors in log
 ### Player Movement
 - [ ] WASD moves the character
 - [ ] Mouse rotates the camera
 - [ ] Space bar makes the character jump
 - [ ] Left Shift enables sprint (movement speed increases)
 ### State Manager
 - [ ] Print String shows "StateManager Ready. Default: Framework.State.Action.Idle"
 - [ ] `Is Action Permitted(Framework.Action.Sprint)` returns true when idle
 - [ ] Force a state change → verify dispatcher fires
 ### Health / Damage
 - [ ] `BPC_HealthSystem` component is valid (not null)
 - [ ] Call `Apply Damage` from a cheat / debug key → health decreases
 - [ ] OnHealthChanged dispatcher fires
 - [ ] Health reaches 0 → OnDeath fires (if wired)
 ### Inventory
 - [ ] `BPC_InventorySystem` component is valid
 - [ ] Call `Add Item(DA_Item_TestMedKit, 3)` → success
 - [ ] `Get Item Count` returns 3
 - [ ] `Get All Items` returns array with MedKit
 - [ ] `Get Remaining Weight` decreases by 3.0
 ### Save/Load
 - [ ] `Get Subsystem(SS_SaveManager)` returns a valid reference
 - [ ] `Quick Save` → completes without error
 - [ ] `Get Slot Manifest` shows slot 0 as non-empty
 - [ ] `Quick Load` → restores game state
 ### Input Manager
 - [ ] `SS_EnhancedInputManager` is valid
 - [ ] `Is Context Active(Framework.Input.Context.Default)` returns true
 - [ ] `Get Top Context` returns Default context tag
 ### Gameplay Tags
 - [ ] `DA_GameTagRegistry.Validate Tag(Framework.Player.State.Alive)` returns true
 - [ ] `Get All Registered Tags` returns non-empty array
 - [ ] Tag `Framework.Player.State.Alive` is in the returned array
 ### State Gating
 - [ ] `StateManager.Is Action Permitted(Framework.Action.FireWeapon)` returns true (when idle)
 - [ ] After death: `Is Action Permitted(Framework.Action.FireWeapon)` returns false
 - [ ] After respawn: permissions restore
 ---
 ## 11. Next Steps — Expanding the Prototype
 Once the core loop works, build these additional systems in priority order:
 ### Priority 1 — Make It Playable
 1. Build `BPC_InteractionDetector` (spec #16) — raycast to interactables, show prompts
 2. Build `BP_ItemPickup` (spec #25) — place items in world, pick them up
 3. Build `WBP_HUDController` (spec #47) — health/stamina/stress bars on screen
 4. Wire health damage to screen effects (red vignette on low health)
 ### Priority 2 — Combat Loop
 5. Build `BP_WeaponBase` (spec #69) — basic weapon with fire animation
 6. Build `BPC_FirearmSystem` (spec #74) — hitscan fire, damage application
 7. Wire `BPC_DamageReceptionSystem.ApplyDamage()` to weapon fire events
 8. Build `BPC_HitReactionSystem` (spec #75) — add stagger/ragdoll animations
 ### Priority 3 — Save/Death Loop
 9. Build `BPC_DeathHandlingSystem` (spec #39) — death screen, respawn timer
 10. Build `BP_Checkpoint` (spec #37) — save on touch, respawn point
 11. Build `BPC_PlayerRespawnSystem` (spec #42) — checkpoint loading
 ### Priority 4 — Inventory UI
 12. Build `WBP_InventoryMenu` (spec #49) — grid display, item drag-drop
 13. Build `BPC_EquipmentSlotSystem` (spec #30) — weapon/armor slots
 14. Build `BPC_ConsumableSystem` (spec #28) — use medkits from inventory
 ### Priority 5 — Full Systems
 15. Build remaining Player systems (12-15)
 16. Build Interaction systems (17-23)
 17. Build Narrative systems (58-68)
 18. Build AI systems (80-88)
 19. Build Adaptive systems (89-101)
 20. Build UI, Meta, Settings, Polish (44-57, 102-114)
 > See [`docs/checklists/remaining-blueprint-build-order.md`](../checklists/remaining-blueprint-build-order.md) for the complete build order across all 135 systems.
 ---
 ## 12. Troubleshooting
 ### "GameplayTag is not valid" / Tags show as "Invalid"
 **Fix:** Add all 11 `DT_Tags_*` Data Tables to `Project Settings → Gameplay Tags → Gameplay Tag Table List`. Restart editor. Verify tags are in `.ini` cache: check `Saved/Config/WindowsEditor/GameplayTags.ini` for entries.
 ### "SS_SaveManager not found" / Subsystem is null
 **Fix:** Ensure `BP_GameFramework` is set as the Default Game Instance in Project Settings. `UGameInstanceSubsystem` lifecycles only trigger under the assigned GameInstance.
 ### "Enhanced Input not working" — character doesn't move
 **Fix:** 
 1. Ensure `Enhanced Input` plugin is enabled in Plugins
 2. Ensure `IMC_Default` is pushed in `PC_CoreController.BeginPlay`
 3. Ensure Input Actions are bound in player character's `Setup Player Input Component`
 ### "BPC_StateManager.GatingTable is null"
 **Fix:** Create `DA_StateGatingTable` Data Asset (class: `DA_StateGatingTable`), populate at least 1 rule, then assign it to the `StateManager` component's `Gating Table` property in `BP_PlayerCharacter`.
 ### "Cannot find class DA_GameTagRegistry" in Content Browser
 **Fix:** The C++ class must be compiled before it appears. Ensure `PG_Framework` module is in `PG_Prototype.Build.cs` and the project compiled successfully. Check `Window → Developer Tools → Modules` for `PG_Framework`.
 ### Compile error: "EnhancedInputModule not found"
 **Fix:** Add `"EnhancedInput"` to `PublicDependencyModuleNames` in `PG_Prototype.Build.cs`.
 ### "Inventory Add Item returns 0"
 **Fix:** Check `InventorySystem.MaxWeight` — if too low, items can't be added. Check `DA_ItemData.StackLimit` — must be >= 1. Check `GridWidth` and `GridHeight` — must be > 0.
 ### "Force State Change doesn't block actions"
 **Fix:** The `DA_StateGatingTable` must have gating rules that block the action when the force state is active. Example: rule `Framework.Action.FireWeapon` blocked by `Framework.State.Action.Cutscene` marked `IsBlocked = true`.
 ---
 ## Reference Files
 | Document | Path |
 |----------|------|
 | Complete BP build order | `docs/checklists/remaining-blueprint-build-order.md` |
 | C++ per-class setup guide | `docs/developer/cpp-integration-guide.md` |
 | Full project migration guide | `docs/developer/project-setup-migration.md` |
 | C++/BP status grid | `docs/checklists/cpp-blueprint-status.md` |
 | State Manager architecture | `docs/architecture/bpc-statemanager.md` |
 | Blueprint spec INDEX | `docs/blueprints/INDEX.md` |
 | Developer docs INDEX | `docs/developer/INDEX.md` |
 ---
 *Project Prototype Guide v1.0 — Build a working PG_Framework prototype in under 4 hours.*