Add asset creation sheets for various systems and UI components

- Created Save/Load & Death Loop asset sheet detailing checkpoint, death handling, and respawn systems. - Added UI widget creation sheets for pause menu, settings menu, inventory, journal viewer, objective display, notification toast, screen effect controller, accessibility UI, diegetic HUD frame, menu flow controller, and credits screen. - Implemented HUD controller and interaction prompt display assets with detailed wiring instructions. - Established narrative systems asset sheet including components for narrative state, objectives, dialogue playback, and branching consequences. - Developed weapons, AI, and adaptive systems asset creation sheet outlining weapon base, enemy AI components, and adaptive gameplay mechanics. - Compiled meta, settings, and polish asset creation sheet covering progress tracking, achievement systems, accessibility settings, and various polish components. - Defined input actions and mapping contexts for enhanced input system, including gameplay actions and context priorities. - Created state management assets including enums, structs, data asset, and state manager component for action gating and state transitions.
Update Developer Reference and add C++ Integration Guide
2026-05-20 15:34:06 +03:00 · 2026-05-20 15:16:32 +03:00
22 changed files with 2857 additions and 11 deletions
--- a/docs/blueprints/01-core/BP_CoreGameMode.asset.md
+++ b/docs/blueprints/01-core/BP_CoreGameMode.asset.md
@@ -0,0 +1,71 @@
 # BP_CoreGameMode — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/Core/BP_CoreGameMode`
 > **Parent Class:** `GM_CoreGameMode` (C++) or `GameModeBase`
 > **Asset Type:** Blueprint Class (GameMode)
 ---
 ## Create This Asset
 ### Step 1: Create Blueprint
 1. Content Browser → `Content/Framework/Core/`
 2. Right-click → **Blueprint Class**
 3. Parent: `GM_CoreGameMode` (C++) OR `GameModeBase`
 4. Name: `BP_CoreGameMode`
 ### Step 2: Set as Default GameMode
 **Project Settings → Maps & Modes → Default GameMode** → `BP_CoreGameMode`
 ### Step 3: Configure Class Defaults
 | Variable | Type | Value |
 |----------|------|-------|
 | `GameState Class` | `AGS_CoreGameState` | `BP_CoreGameState` |
 | `Player Controller Class` | `APlayerController` | Your `BP_CorePlayerController` |
 | `Default Pawn Class` | `APawn` | Your GASP player pawn |
 | `HUD Class` | `AHUD` | `WBP_HUDController` |
 ---
 ## What to Wire
 ### Function: TransitionToChapter
 ```
 Input: ChapterTag (GameplayTag)
 [BlueprintCallable]
  ├─ Branch: CurrentGamePhase == Loading?
  │   True → Print Warning: "Already loading" → Return
  ├─ Set CurrentChapterTag = ChapterTag
  ├─ Switch HasAuthority → True:
  │   ├─ Get GameInstance → Cast to GI_GameFramework
  │   ├─ SetGamePhase(Loading)
  │   ├─ Get GameState → Cast to GS_CoreGameState → SetChapter(ChapterTag)
  │   ├─ Open Level (by ChapterTag mapping — use Data Asset lookup)
  │   └─ On level loaded → SetGamePhase(InGame)
  └─ Call OnChapterTransition(ChapterTag)
 ```
 ### Function: HandlePlayerDead
 ```
 Input: DeadController (AController)
 [BlueprintCallable]
  ├─ IsValid(DeadController)? → False: Return
  ├─ Set bPauseAllowed = false
  ├─ Get GameInstance → Cast to GI_GameFramework → SetGamePhase(DeathLoop)
  └─ TODO: Route to respawn or AltDeathSpace
 ```
 ### Event Dispatchers to Create
 | Dispatcher | Parameters |
 |------------|-----------|
 | `OnChapterTransition` | `NewChapter` (GameplayTag) |
 | `OnGameOverTriggered` | `EndingTag` (GameplayTag) |
 ---
 ## Test It
 - [ ] PIE: check output log for "GM_CoreGameMode::InitGame"
 - [ ] Check that player spawns with correct pawn
 - [ ] Call `TransitionToChapter` → phase changes to Loading → level loads
--- a/docs/blueprints/01-core/BP_CoreGameState.asset.md
+++ b/docs/blueprints/01-core/BP_CoreGameState.asset.md
@@ -0,0 +1,88 @@
 # BP_CoreGameState — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/Core/BP_CoreGameState`
 > **Parent Class:** `GS_CoreGameState` (C++) or `GameStateBase`
 > **Asset Type:** Blueprint Class (GameState)
 ---
 ## Create This Asset
 ### Step 1: Create Blueprint
 1. Content Browser → `Content/Framework/Core/`
 2. Right-click → **Blueprint Class**
 3. Parent: `GS_CoreGameState` (C++) OR `GameStateBase`
 4. Name: `BP_CoreGameState`
 ### Step 2: Assign in GameMode
 Open `BP_CoreGameMode` → Class Defaults → `GameState Class` → `BP_CoreGameState`
 ---
 ## What to Wire
 ### Variables (if BP-only GameStateBase)
 | Variable | Type | Replication | Default |
 |----------|------|-------------|---------|
 | `ElapsedPlayTime` | `Float` | Replicated | `0.0` |
 | `ActiveChapterTag` | `GameplayTag` | Replicated | Empty |
 | `ActiveNarrativePhase` | `GameplayTag` | Replicated | Empty |
 | `bEncounterActive` | `Boolean` | Replicated | `false` |
 | `ActiveObjectiveTags` | `Array<GameplayTag>` | Replicated | Empty |
 ### Override: BeginPlay
 ```
 [Event BeginPlay]
  ├─ Parent: BeginPlay
  ├─ Get GameInstance → Cast to GI_GameFramework → Store as CachedFramework
  └─ Enable Tick
 ```
 ### Override: Tick
 ```
 [Event Tick]
  ├─ IsValid(CachedFramework)? AND CurrentGamePhase == InGame?
  │   True → ElapsedPlayTime += DeltaSeconds
  │   ├─ TimeUpdateAccumulator += DeltaSeconds
  │   └─ Accumulator >= 1.0?
  │       ├─ Reset accumulator
  │       └─ Call OnElapsedPlayTimeUpdated(ElapsedPlayTime)
 ```
 ### Function: SetChapter
 ```
 Input: ChapterTag (GameplayTag)
 [Server-only]
  ├─ If ChapterTag == ActiveChapterTag → Return
  ├─ Set ActiveChapterTag = ChapterTag
  └─ Call OnChapterChanged(ChapterTag)
 ```
 ### Function: AddObjective / RemoveObjective
 ```
 AddObjective(ObjectiveTag):
  ├─ If already in array → Return
  ├─ Add to ActiveObjectiveTags
  └─ Call OnObjectiveTagsChanged
 RemoveObjective(ObjectiveTag):
  ├─ Remove from array
  └─ Call OnObjectiveTagsChanged
 ```
 ### Event Dispatchers to Create
 | Dispatcher | Parameters |
 |------------|-----------|
 | `OnElapsedPlayTimeUpdated` | `ElapsedSeconds` (Float) |
 | `OnChapterChanged` | `NewChapter` (GameplayTag) |
 | `OnNarrativePhaseChanged` | `NewPhase` (GameplayTag) |
 | `OnEncounterActiveStateChanged` | `bActive` (Boolean) |
 | `OnObjectiveTagsChanged` | (none) |
 ---
 ## Test It
 - [ ] PIE: check that GS_CoreGameState spawns
 - [ ] Call SetChapter → OnChapterChanged fires → HUD updates
 - [ ] Call AddObjective → OnObjectiveTagsChanged fires → objective list refreshes
--- a/docs/blueprints/01-core/BP_GameFramework.asset.md
+++ b/docs/blueprints/01-core/BP_GameFramework.asset.md
@@ -0,0 +1,78 @@
 # BP_GameFramework — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/Core/BP_GameFramework`
 > **Parent Class:** `GI_GameFramework` (C++) or `GameInstance` (BP-only)
 > **Asset Type:** Blueprint Class (GameInstance)
 ---
 ## Create This Asset
 ### Step 1: Create Blueprint
 1. Content Browser → `Content/Framework/Core/`
 2. Right-click → **Blueprint Class**
 3. Parent: `GI_GameFramework` (C++) OR `GameInstance`
 4. Name: `BP_GameFramework`
 ### Step 2: Set as Game Instance Class
 **Project Settings → Maps & Modes → Game Instance Class** → `BP_GameFramework`
 ### Step 3: Configure Class Defaults
 | Variable | Type | Value |
 |----------|------|-------|
 | `TagRegistry` | `DA_GameTagRegistry` | Assign `DA_GameTagRegistry` asset |
 | `bValidateTagsOnInit` | `Boolean` | `true` |
 | `bLogTagsOnInit` | `Boolean` | `true` (dev) / `false` (ship) |
 ---
 ## What to Wire
 ### Override: Event Init
 ```
 [Event Init]
  ├─ Parent: Event Init
  ├─ Print String: "BP_GameFramework: Init started"
  ├─ Branch: bValidateTagsOnInit?
  │   True → Call ValidateFrameworkTags (see below)
  ├─ IsValid(TagRegistry)? → Branch
  │   False → Print Error → Call OnFrameworkInitFailed("TagRegistry not assigned")
  │   True →
  │       ├─ Set bFrameworkInitialized = true
  │       ├─ Call OnFrameworkReady
  │       └─ Print String: "Framework ready"
 ```
 ### Function: ValidateFrameworkTags
 ```
 [BlueprintCallable, Private]
  ├─ IsValid(TagRegistry)? → Branch
  │   False → Print Error → Return
  ├─ TagRegistry → GetAllRegisteredTags → AllTags
  ├─ Array Length(AllTags) → TagCount
  ├─ Branch: TagCount == 0?
  │   True → Print Warning: "No Gameplay Tags registered!"
  │   False → Print: "{TagCount} tags registered"
  ├─ Branch: bLogTagsOnInit?
  │   True → TagRegistry → LogAllTags
  └─ Return
 ```
 ### Function: IsFrameworkReady
 ```
 [BlueprintPure, Public] → Boolean
  └─ Return bFrameworkInitialized
 ```
 ### Event Dispatchers to Create
 | Dispatcher | Parameters |
 |------------|-----------|
 | `OnFrameworkReady` | (none) |
 | `OnFrameworkInitFailed` | `ErrorReason` (String) |
 ---
 ## Test It
 - [ ] PIE: output log shows "Framework ready" and tag count
 - [ ] Clear TagRegistry variable → PIE → `OnFrameworkInitFailed` fires
 - [ ] Set `bLogTagsOnInit = true` → all tag names printed to log
--- a/docs/blueprints/01-core/DA_GameTagRegistry.asset.md
+++ b/docs/blueprints/01-core/DA_GameTagRegistry.asset.md
@@ -0,0 +1,68 @@
 # DA_GameTagRegistry — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/Core/DA_GameTagRegistry`
 > **Parent Class:** `DA_GameTagRegistry` (C++) or `PrimaryDataAsset` (BP-only)
 > **Asset Type:** Data Asset
 ---
 ## Create This Asset
 ### Step 1: Create Data Asset
 1. Content Browser → `Content/Framework/Core/`
 2. Right-click → **Miscellaneous → Data Asset**
 3. Class: `DA_GameTagRegistry` (if C++ compiled) OR `PrimaryDataAsset`
 4. Name: `DA_GameTagRegistry`
 ### Step 2: Configure Class Defaults (if BP-only PrimaryDataAsset)
 | Variable | Type | Value |
 |----------|------|-------|
 | `TagNamespace` | `Text` | `"Framework tag namespace documentation"` |
 | `bIsFrameworkTag` | `Boolean` | `true` |
 | `TagDataTables` | `Array<Data Table>` | Add all 11 DT_Tags_* tables |
 ### Step 3: Assign to GameInstance
 Open `BP_GameFramework` → Class Defaults → `TagRegistry` → assign `DA_GameTagRegistry`
 ---
 ## What to Wire (BP-Only Version)
 ### Function: GetAllRegisteredTags
 ```
 Inputs: none → Output: Array<GameplayTag>
 [Pure Function Graph]
  ├─ Make Array<GameplayTag> → LocalTags
  ├─ ForEachLoop (TagDataTables)
  │   ├─ Branch: IsValid(Array Element)?
  │   │   True → Get Data Table Row Names
  │   │   └─ ForEachLoop (RowNames)
  │   │       └─ Get Data Table Row → Break GameplayTagTableRow → Tag
  │   │           └─ ADD to LocalTags
  └─ Return LocalTags
 ```
 ### Function: ValidateTag
 ```
 Input: Tag (GameplayTag) → Output: Boolean
 [Pure Function Graph]
  └─ Is Gameplay Tag Valid(Tag) → Return
 ```
 ### Function: GetTagDisplayName
 ```
 Input: Tag (GameplayTag) → Output: Text
 [Pure Function Graph]
  └─ Get Tag Display Name(Tag) → Return
 ```
 ---
 ## Test It
 - [ ] Open `DA_GameTagRegistry` → verify `TagDataTables` has 11 entries
 - [ ] PIE: output log shows `"N tags registered across 11 Data Tables"`
 - [ ] Call `ValidateTag(Framework.Player.State.Alive)` → returns `true`
 - [ ] Call `ValidateTag(Unregistered.Tag)` → returns `false`
--- a/docs/blueprints/01-core/DT_Tags_All.asset.md
+++ b/docs/blueprints/01-core/DT_Tags_All.asset.md
@@ -0,0 +1,59 @@
 # DT_Tags_* — Data Tables (11 assets)
 > **UE5 Assets:** `Content/Framework/Core/DataTables/DT_Tags_{Category}`
 > **Row Structure:** `GameplayTagTableRow`
 > **Count:** 11 tables
 ---
 ## Create These Assets
 ### Step 1: Create All 11 Data Tables
 For each category below, repeat this process:
 1. Content Browser → `Content/Framework/Core/DataTables/`
 2. Right-click → **Miscellaneous → Data Table**
 3. Row Structure: `GameplayTagTableRow`
 4. Name: `DT_Tags_{Category}`
 5. Right-click the Data Table → **Import** → select the CSV file from `docs/blueprints/01-core/data-tables/DT_Tags_{Category}.csv`
 ### The 11 Tables
 | # | Data Table | CSV Source | Namespaces |
 |---|-----------|------------|------------|
 | 1 | `DT_Tags_Player` | `DT_Tags_Player.csv` | Player.State, Stress, Posture, Movement, Camera, Body, Overlay, Vitals |
 | 2 | `DT_Tags_Interaction` | `DT_Tags_Interaction.csv` | Interaction.Type, Context, Prompt, HidingSpot, Traversal, Door |
 | 3 | `DT_Tags_Item` | `DT_Tags_Item.csv` | Item.Type, Slot, Rarity, Context |
 | 4 | `DT_Tags_Narrative` | `DT_Tags_Narrative.csv` | Narrative.Flag, Phase, Choice, Ending, Trial, Cutscene, Lore, Objective |
 | 5 | `DT_Tags_AI` | `DT_Tags_AI.csv` | AI.Alert, Archetype, Stimulus, Behavior, Memory |
 | 6 | `DT_Tags_Save` | `DT_Tags_Save.csv` | Save, DeathSpace, Checkpoint, Respawn, RunHistory |
 | 7 | `DT_Tags_Environment` | `DT_Tags_Environment.csv` | Environment.Atmosphere, Scare, Light, Pacing, Performance |
 | 8 | `DT_Tags_Combat` | `DT_Tags_Combat.csv` | Combat.Damage, Weapon, Ammo, FireMode, HitReaction, Feedback, Shield |
 | 9 | `DT_Tags_State` | `DT_Tags_State.csv` | State.Action, Overlay, Vital, Gating |
 | 10 | `DT_Tags_Audio` | `DT_Tags_Audio.csv` | Audio.Bus, Room, Parameter, Surface |
 | 11 | `DT_Tags_Achievement` | `DT_Tags_Achievement.csv` | Achievement |
 ### Step 2: Register All Tables with Engine
 **⚠️ CRITICAL — Without this, NO tags are recognized!**
 1. **Project Settings → GameplayTags → Gameplay Tag Table List**
 2. Click `+` 11 times
 3. Assign each `DT_Tags_*` Data Table to a slot
 4. Restart editor (or recompile Blueprints) to refresh tag cache
 ### CSV Format
 Each CSV has 3 columns:
 ```
 Name,Tag,DevComment
 Alive,"Framework.Player.State.Alive","Player is alive"
 Dead,"Framework.Player.State.Dead","Player is dead"
 ...
 ```
 ---
 ## Test It
 - [ ] Open `DA_GameTagRegistry` → call `GetAllRegisteredTags()` → returns ~334 tags
 - [ ] Make Literal Gameplay Tag → type `Framework.Player.State.Alive` → recognized (not red)
 - [ ] `Is Gameplay Tag Valid(Framework.Player.State.Alive)` → `true`
 - [ ] `Is Gameplay Tag Valid(Fake.Tag)` → `false`
--- a/docs/blueprints/02-player/BPC_HealthSystem.asset.md
+++ b/docs/blueprints/02-player/BPC_HealthSystem.asset.md
@@ -0,0 +1,98 @@
 # BPC_HealthSystem — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/Player/BPC_HealthSystem`
 > **Parent Class:** `ActorComponent`
 > **Attach To:** Player pawn + Enemy pawns
 ---
 ## Create This Asset
 1. Content Browser → `Content/Framework/Player/`
 2. Right-click → **Blueprint Class** → Parent: `ActorComponent`
 3. Name: `BPC_HealthSystem`
 ---
 ## Variables to Add
 | Variable | Type | Default | Category |
 |----------|------|---------|----------|
 | `MaxHealth` | `Float` | `100.0` | Config |
 | `CurrentHealth` | `Float` | `100.0` | State |
 | `bIsDead` | `Boolean` | `false` | State |
 | `DamageResistance` | `Float` | `0.0` | Config |
 | `bCanHeal` | `Boolean` | `true` | Config |
 | `HealthRegenRate` | `Float` | `0.0` | Config |
 | `HealthRegenDelay` | `Float` | `5.0` | Config |
 | `LastDamageTime` | `Float` | `0.0` | State |
 ---
 ## What to Wire
 ### Override: BeginPlay
 ```
 [Event BeginPlay]
  ├─ Set CurrentHealth = MaxHealth
  └─ Enable Tick (if regen > 0)
 ```
 ### Function: ApplyDamage
 ```
 Input: DamageAmount(Float), DamageCauser(AActor), DamageType(GameplayTag)
 [BlueprintCallable]
  ├─ Branch: bIsDead? → True: Return 0
  ├─ Calculate: EffectiveDamage = DamageAmount * (1.0 - DamageResistance)
  ├─ Set CurrentHealth = FMax(CurrentHealth - EffectiveDamage, 0)
  ├─ Set LastDamageTime = GetGameTimeInSeconds
  ├─ Call OnHealthChanged(CurrentHealth, MaxHealth, -EffectiveDamage)
  ├─ Branch: CurrentHealth <= 0?
  │   True → Set bIsDead = true → Call OnDeath(DamageCauser)
  └─ Return EffectiveDamage
 ```
 ### Function: Heal
 ```
 Input: HealAmount(Float)
 [BlueprintCallable]
  ├─ Branch: bIsDead? → True: Return 0
  ├─ Branch: Not bCanHeal? → True: Return 0
  ├─ Calculate: ActualHeal = FMin(HealAmount, MaxHealth - CurrentHealth)
  ├─ Set CurrentHealth += ActualHeal
  ├─ Call OnHealthChanged(CurrentHealth, MaxHealth, ActualHeal)
  └─ Return ActualHeal
 ```
 ### Override: Tick
 ```
 [Event Tick]
  ├─ Branch: bIsDead OR HealthRegenRate <= 0 → Return
  ├─ Branch: (GameTime - LastDamageTime) < HealthRegenDelay → Return
  ├─ Heal(HealthRegenRate * DeltaSeconds)
 ```
 ### Event Dispatchers to Create
 | Dispatcher | Parameters |
 |------------|-----------|
 | `OnHealthChanged` | `Current` (Float), `Max` (Float), `Delta` (Float) |
 | `OnDeath` | `Killer` (AActor) |
 | `OnHealed` | `Amount` (Float), `Healer` (AActor) |
 | `OnDamageReceived` | `Amount` (Float), `Causer` (AActor), `Type` (GameplayTag) |
 ---
 ## Attach to Pawn
 1. Open player pawn Blueprint
 2. **Add Component → BPC_HealthSystem**
 3. Optionally adjust `MaxHealth`, `DamageResistance` in Details panel
 ---
 ## Test It
 - [ ] PIE: check BeginPlay → CurrentHealth = 100
 - [ ] Call ApplyDamage(25) → health drops to 75 → OnHealthChanged fires
 - [ ] Call Heal(10) → health rises to 85 → OnHealed fires
 - [ ] Call ApplyDamage(100) → death → OnDeath fires → bIsDead = true
--- a/docs/blueprints/02-player/BPC_PlayerComponents_All.asset.md
+++ b/docs/blueprints/02-player/BPC_PlayerComponents_All.asset.md
@@ -0,0 +1,138 @@
 # BPC_StaminaSystem / BPC_StressSystem / BPC_MovementStateSystem
 # BPC_HidingSystem / BPC_EmbodimentSystem / BPC_CameraStateLayer / BPC_PlayerMetricsTracker
 #
 # Player Component Assets — Quick Creation Sheet (7 components)
 > **UE5 Path:** `Content/Framework/Player/`
 > **Parent Class:** `ActorComponent`
 > **Attach To:** Player pawn
 ---
 ## Quick Creation — All 7 Components
 For each component below:
 1. Content Browser → `Content/Framework/Player/`
 2. Right-click → **Blueprint Class** → Parent: `ActorComponent`
 3. Name: as listed
 4. Attach to player pawn Blueprint via **Add Component**
 ---
 ## BPC_StaminaSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `MaxStamina` | Float | `100.0` |
 | `CurrentStamina` | Float | `100.0` |
 | `SprintDrainRate` | Float | `10.0` |
 | `StaminaRegenRate` | Float | `5.0` |
 | `ExhaustionThreshold` | Float | `10.0` |
 | `bExhausted` | Boolean | `false` |
 **Key Functions:** `ConsumeStamina(Amount)`, `IsExhausted()`
 **Dispatchers:** `OnStaminaChanged`, `OnExhaustionStateChanged`
 ---
 ## BPC_StressSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `CurrentStress` | Float | `0.0` |
 | `StressDecayRate` | Float | `1.0` |
 | `StressTier` | Enum (E_PlayerVitalSignals) | `Calm` |
 **Key Functions:** `AddStress(Amount, Source)`, `GetStressTier()`
 **Dispatchers:** `OnStressChanged`, `OnStressTierChanged(Tier)`
 **Stress Tiers:** Calm → Tense → Anxious → Fearful → Catatonic
 ---
 ## BPC_MovementStateSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `CurrentMovementMode` | GameplayTag | `Framework.Player.Movement.Standing` |
 | `CurrentPosture` | GameplayTag | `Framework.Player.Posture.Standing` |
 | `bIsSprinting` | Boolean | `false` |
 | `bIsCrouching` | Boolean | `false` |
 **Key Functions:** `SetMovementMode(Tag)`, `SetPosture(Tag)`, `GetMovementIntensity()`
 **Dispatchers:** `OnMovementModeChanged`, `OnPostureChanged`
 **GASP Liaison:** This component updates GASP variables — never modify GASP directly.
 ---
 ## BPC_HidingSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `CurrentHideState` | GameplayTag | `Framework.Player.State.Exposed` |
 | `bIsPeeking` | Boolean | `false` |
 | `bIsHoldingBreath` | Boolean | `false` |
 | `BreathHoldMax` | Float | `8.0` |
 | `BreathHoldCurrent` | Float | `8.0` |
 **Key Functions:** `EnterHide(HidingSpot)`, `ExitHide()`, `Peek()`, `HoldBreath()`
 **Dispatchers:** `OnHideStateChanged`, `OnBreathHoldChanged`
 ---
 ## BPC_EmbodimentSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `bFirstPersonBodyVisible` | Boolean | `true` |
 | `bArmsOnlyMode` | Boolean | `false` |
 | `BodyMesh` | SkeletalMesh | (assign) |
 **Key Functions:** `SetBodyVisibility(bVisible)`, `SetArmsOnlyMode(bActive)`
 **Dispatchers:** `OnEmbodimentModeChanged`
 ---
 ## BPC_CameraStateLayer
 | Variable | Type | Default |
 |----------|------|---------|
 | `BaseFOV` | Float | `90.0` |
 | `CurrentFOV` | Float | `90.0` |
 | `FOVSmoothSpeed` | Float | `5.0` |
 | `CameraOffset` | Vector | `(0,0,0)` |
 **Key Functions:** `SetFOVOverride(Tag, FOV)`, `ClearFOVOverride(Tag)`, `SetCameraOffset(Tag, Offset)`
 **Dispatchers:** `OnFOVChanged`, `OnCameraOffsetChanged`
 ---
 ## BPC_PlayerMetricsTracker
 | Variable | Type | Default |
 |----------|------|---------|
 | `TotalShotsFired` | Integer | `0` |
 | `TotalShotsHit` | Integer | `0` |
 | `TotalDeaths` | Integer | `0` |
 | `TotalKills` | Integer | `0` |
 | `Accuracy` | Float | `0.0` |
 | `KDRatio` | Float | `0.0` |
 **Key Functions:** `RecordShot(bHit)`, `RecordDeath()`, `RecordKill()`, `GetAccuracy()`
 **Dispatchers:** `OnMetricsUpdated`
 ---
 ## Test All Components
 - [ ] All 7 components visible on player pawn
 - [ ] BeginPlay sets default values correctly
 - [ ] Each dispatcher fires when its state changes
 - [ ] Components don't conflict (Stamina drain doesn't affect Stress directly — let StateManager coordinate)
--- a/docs/blueprints/03-interaction/InteractionAssets_All.asset.md
+++ b/docs/blueprints/03-interaction/InteractionAssets_All.asset.md
@@ -0,0 +1,129 @@
 # Interaction Systems — Asset Creation Sheet (8 assets)
 > **UE5 Path:** `Content/Framework/Interaction/`
 ---
 ## BPC_InteractionDetector (Component)
 **Parent:** `ActorComponent` → Attach to player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `InteractionRange` | Float | `300.0` |
 | `InteractionChannel` | TraceChannel | `Visibility` |
 | `HoldDuration` | Float | `0.5` |
 | `CurrentFocusedActor` | Actor | None |
 **Key Logic:**
 ```
 Tick → LineTraceByChannel(Camera Forward * Range)
  ├─ Hit actor implements I_Interactable?
  │   True → if different from CurrentFocused → Call OnFocusBegin on new, OnFocusEnd on old
  │   False → Clear focus
  ├─ If holding interact → accumulate hold timer
  │   Timer >= HoldDuration → trigger OnInteract
  └─ Fire dispatchers: OnFocusBegin, OnFocusEnd, OnHoldProgress
 ```
 **Dispatchers:** `OnInteractionDetected(Actor, PromptText)`, `OnFocusLost`, `OnHoldProgress(Float)`
 ---
 ## I_HidingSpot (Interface)
 **Create:** Right-click → **Blueprint → Blueprint Interface** → Name: `I_HidingSpot`
 | Function | Inputs | Outputs |
 |----------|--------|---------|
 | `CanPlayerHide` | `Player` (Actor) | `Boolean`, `BlockReason` (Text) |
 | `OnPlayerEnter` | `Player` (Actor) | — |
 | `OnPlayerExit` | `Player` (Actor) | — |
 | `GetEntryTransform` | — | `Transform` |
 | `GetPeekTransforms` | — | `Array<Transform>` |
 | `IsOccupied` | — | `Boolean` |
 | `GetHidingSpotType` | — | `GameplayTag` |
 ---
 ## BPC_DiegeticDisplay (Component)
 **Parent:** `ActorComponent` → Attach to wristwatch/helmet actor
 | Variable | Type | Default |
 |----------|------|---------|
 | `DisplayWidgetClass` | `WBP_DiegeticHUDFrame` | Assign |
 | `RenderTarget` | `TextureRenderTarget2D` | 512x512 |
 | `bIsActive` | Boolean | `false` |
 ---
 ## BP_DoorActor (Actor)
 **Parent:** `Actor` → Add StaticMesh (door frame) + StaticMesh (door panel)
 | Variable | Type | Default |
 |----------|------|---------|
 | `DoorState` | GameplayTag | `Framework.Interaction.Door.Closed` |
 | `bIsLocked` | Boolean | `false` |
 | `RequiredKeyTag` | GameplayTag | Empty |
 | `OpenAngle` | Float | `90.0` |
 | `OpenSpeed` | Float | `3.0` |
 **Implements:** `I_Interactable`, `I_Lockable`, `I_Toggleable`, `I_Persistable`
 ---
 ## BP_PuzzleDeviceActor (Actor)
 **Parent:** `Actor` → Base class for all puzzle devices
 | Variable | Type | Default |
 |----------|------|---------|
 | `PuzzleData` | `DA_PuzzleData` | Assign |
 | `CurrentStep` | Integer | `0` |
 | `bIsSolved` | Boolean | `false` |
 | `ActivationSequence` | `Array<Actor>` | Linked devices |
 ---
 ## BPC_ContextualTraversalSystem (Component)
 **Attach to:** Player pawn — works with GASP Motion Warping
 | Variable | Type | Default |
 |----------|------|---------|
 | `TraversalTraceDistance` | Float | `200.0` |
 | `VaultHeight` | Float | `120.0` |
 | `MantleHeight` | Float | `200.0` |
 ---
 ## BPC_PhysicsDragSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `DragForce` | Float | `500.0` |
 | `HoldDistance` | Float | `200.0` |
 | `HeldActor` | Actor | None |
 ---
 ## BPC_UsableWorldObjectSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `CurrentUsable` | Actor | None |
 | `bIsUsing` | Boolean | `false` |
 ---
 ## Test These
 - [ ] Walk up to door → prompt "Open Door [E]" → press E → door opens
 - [ ] Locked door → prompt "Locked — Requires Key Card" → can't open
 - [ ] Run toward low wall → auto-vault (ContextualTraversal)
 - [ ] Grab physics object → drags in front of player → release throws
--- a/docs/blueprints/04-inventory/InventoryAssets_All.asset.md
+++ b/docs/blueprints/04-inventory/InventoryAssets_All.asset.md
@@ -0,0 +1,111 @@
 # Inventory Systems — Asset Creation Sheet (10 assets)
 > **UE5 Path:** `Content/Framework/Inventory/`
 ---
 ## C++ Already Done
 - `BPC_InventorySystem` (31) — attach directly to pawn
 - `DA_ItemData` (07) — create Data Asset instances per item
 ---
 ## BP Assets to Create
 ### BP_ItemPickup (Actor)
 **Parent:** `Actor` → Add StaticMesh, SphereCollision, RotatingMovement
 | Variable | Type | Default |
 |----------|------|---------|
 | `ItemData` | `DA_ItemData` | Assign |
 | `Quantity` | Integer | `1` |
 | `BobAmplitude` | Float | `0.5` |
 | `BobSpeed` | Float | `2.0` |
 **Implements:** `I_Interactable`
 **OnInteract:**
 ```
  ├─ Get Player → BPC_InventorySystem → CanAddItem(ItemData)?
  │   True → AddItem(ItemData, Quantity) → Destroy self
  │   False → Show "Inventory Full" prompt
 ```
 ### BPC_ContainerInventory (Component)
 **Attach to:** Chests, drawers, cabinets, safes
 | Variable | Type | Default |
 |----------|------|---------|
 | `ContainerSlots` | `Array<FInventorySlot>` | Empty |
 | `ContainerSize` | Integer | `12` |
 | `bIsOpen` | Boolean | `false` |
 ### BPC_ActiveItemSystem (Component)
 **Attach to:** Player pawn — manages quick-slot item
 | Variable | Type | Default |
 |----------|------|---------|
 | `QuickSlotCount` | Integer | `4` |
 | `ActiveItemIndex` | Integer | `0` |
 | `QuickSlots` | `Array<DA_ItemData>` | Empty |
 ### BPC_CollectibleTracker (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `FoundCollectibles` | `Array<GameplayTag>` | Empty |
 | `TotalCollectibles` | Integer | `0` |
 | `SetBonuses` | `Array<GameplayTag>` | Empty |
 ### BPC_ConsumableSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `LastConsumedItem` | `DA_ItemData` | None |
 | `UseCooldown` | Float | `0.5` |
 **UseItem(ItemData):**
 ```
  ├─ BPC_HealthSystem → Heal(Item.ConsumableData.HealthRestore)
  ├─ BPC_StressSystem → AddStress(-Item.ConsumableData.StressReduce)
  └─ BPC_InventorySystem → RemoveItem(Item, 1)
 ```
 ### BPC_DocumentArchiveSystem (Component)
 | Variable | Type |
 |----------|------|
 | `ArchivedDocuments` | `Array<GameplayTag>` |
 | `bHasUnread` | Boolean |
 ### BPC_EquipmentSlotSystem (Component)
 | Variable | Type | Default |
 |----------|------|---------|
 | `EquipmentSlots` | `Array<FInventorySlot>` | 6 slots |
 | `EquippedWeapon` | `DA_ItemData` | None |
 ### BPC_ItemCombineSystem (Component)
 | Variable | Type |
 |----------|------|
 | `CraftingRecipes` | `Array<S_CraftingRecipe>` |
 ### BPC_JournalSystem (Component)
 | Variable | Type |
 |----------|------|
 | `ActiveQuests` | `Array<GameplayTag>` |
 | `CompletedQuests` | `Array<GameplayTag>` |
 ### BPC_KeyItemSystem (Component)
 | Variable | Type |
 |----------|------|
 | `KeyItems` | `Array<GameplayTag>` |
 | `bAutoUseOnTarget` | Boolean |
 ---
 ## Test These
 - [ ] Drop item pickup in level → walk over → item added to inventory
 - [ ] Use health pack → health increases, item removed from inventory
 - [ ] Combine items → new item appears in inventory
 - [ ] Equip weapon → appears on character mesh
--- a/docs/blueprints/05-saveload/SaveAssets_All.asset.md
+++ b/docs/blueprints/05-saveload/SaveAssets_All.asset.md
@@ -0,0 +1,124 @@
 # Save/Load & Death Loop — Asset Creation Sheet (9 assets)
 > **UE5 Path:** `Content/Framework/Save/`
 ---
 ## C++ Already Done
 - `SS_SaveManager` (35) — auto-created subsystem, no BP needed
 - `I_Persistable` (36) — in `I_InterfaceLibrary.h`
 ---
 ## BP Assets to Create
 ### BP_Checkpoint (Actor)
 **Parent:** `Actor` → Add BoxCollision (trigger)
 | Variable | Type | Default |
 |----------|------|---------|
 | `CheckpointTag` | GameplayTag | e.g. `Framework.Save.Checkpoint.Chapter1_Start` |
 | `bActivated` | Boolean | `false` |
 | `SpawnTransform` | Transform | (auto-set from actor location) |
 **OnOverlapBegin(Player):**
 ```
  ├─ If bActivated → Return
  ├─ Set bActivated = true
  ├─ Get SaveManager → CreateCheckpoint(CheckpointTag)
  ├─ Play checkpoint sound + particle effect
  └─ Show WBP_NotificationToast: "Checkpoint Reached"
 ```
 ---
 ### BPC_AltDeathSpaceSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `bInAltDeathSpace` | Boolean | `false` |
 | `DeathSpaceScene` | Level | Assign |
 | `ExitFound` | Boolean | `false` |
 ---
 ### BPC_DeathHandlingSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `DeathAnimation` | AnimMontage | Assign |
 | `RespawnDelay` | Float | `3.0` |
 | `bDeathSequencePlaying` | Boolean | `false` |
 **Bind to:** `BPC_HealthSystem.OnDeath`
 **OnDeath(Killer):**
 ```
  ├─ Play DeathAnimation
  ├─ Delay(3.0)
  ├─ Determine outcome:
  │   ├─ AltDeathSpace chance → EnterAltDeathSpace
  │   └─ Normal death → Call GM_CoreGameMode.HandlePlayerDead
  └─ Call BPC_RunHistoryTracker.RecordDeath
 ```
 ---
 ### BPC_PersistentCorpseSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type |
 |----------|------|
 | `CorpsePersistenceDuration` | Float = `-1` (infinite) |
 | `CorpseSnapshotData` | `Array<Byte>` |
 ---
 ### BPC_PersistentWorldStateRecorder (Component)
 **Attach to:** Player pawn or GameState
 | Variable | Type |
 |----------|------|
 | `RecordedStates` | `Array<S_WorldStateEntry>` |
 | `bIsRecording` | Boolean |
 ---
 ### BPC_PlayerRespawnSystem (Component)
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `LastCheckpointTag` | GameplayTag | Empty |
 | `bRespawning` | Boolean | `false` |
 **Respawn():**
 ```
  ├─ Get SaveManager → LoadCheckpoint(active slot)
  ├─ Find BP_Checkpoint with LastCheckpointTag
  ├─ Teleport player to checkpoint transform
  ├─ Restore health, clear death state
  └─ Call BPC_StateManager.RestorePreviousState
 ```
 ---
 ### BPC_RunHistoryTracker (Component)
 **Attach to:** Player pawn
 | Variable | Type |
 |----------|------|
 | `TotalDeaths` | Integer |
 | `TotalPlayTime` | Float |
 | `ChaptersCompleted` | `Array<GameplayTag>` |
 | `CheckpointsReached` | `Array<GameplayTag>` |
 ---
 ## Test These
 - [ ] Walk into checkpoint trigger → toast "Checkpoint Reached" → game saved
 - [ ] Die → death animation plays → respawn at last checkpoint
 - [ ] Alt death → void space loads → find exit → return to normal world
 - [ ] Corpse persists after respawn
--- a/docs/blueprints/06-ui/WBP_AllWidgets_QuickSheet.asset.md
+++ b/docs/blueprints/06-ui/WBP_AllWidgets_QuickSheet.asset.md
@@ -0,0 +1,197 @@
 # WBP_PauseMenu / WBP_SettingsMenu / WBP_InventoryMenu
 # WBP_JournalDocumentViewer / WBP_ObjectiveDisplay
 # WBP_NotificationToast / WBP_ScreenEffectController
 # WBP_AccessibilityUI / WBP_DiegeticHUDFrame
 # WBP_MenuFlowController / WBP_CreditsScreen
 #
 # UI Widget Assets — Quick Creation Sheet (11 widgets)
 > **UE5 Path:** `Content/Framework/UI/`
 > **Parent Class:** `UserWidget`
 ---
 ## WBP_PauseMenu
 **Canvas:** Vertical Box (centered) → Resume, Settings, Save, Load, Quit to Menu, Quit to Desktop
 **Key Logic:**
 ```
 Event Construct:
  └─ Set Input Mode: UI + ShowCursor
 btn_Resume.OnClicked:
  └─ Call SS_UIManager.PopWidget() → Set Input Mode: Game
 ```
 ---
 ## WBP_SettingsMenu
 **Canvas:** Tab buttons (Audio, Video, Controls, Gameplay, Accessibility) + settings panels
 **Key Logic:**
 ```
 Audio Tab → Volume sliders → SS_AudioManager.SetBusVolume(Category, Volume)
 Video Tab → Resolution dropdown, Fullscreen toggle, Quality presets
 Controls Tab → Key rebinding list → SS_EnhancedInputManager.RebindKey(Action, Key)
 Gameplay Tab → Difficulty, subtitle toggle, aim assist
 Accessibility Tab → WBP_AccessibilityUI embedded
 On Apply → SaveSettings → SS_SettingsSystem.ApplyAndSave()
 On Back → If dirty → "Save changes?" dialog
 ```
 ---
 ## WBP_InventoryMenu
 **Canvas:** Grid panel (8 columns) + item detail panel on right + weight bar at bottom
 **Key Logic:**
 ```
 Event Construct:
  ├─ Get Pawn → BPC_InventorySystem → Bind OnInventoryChanged → RefreshGrid
  └─ Bind OnWeightChanged → UpdateWeightBar
 RefreshGrid:
  ├─ Clear Grid children
  └─ For each slot → Create WBP_InventorySlot widget → Add to Grid
 OnSlotClicked(SlotIndex):
  ├─ If dragging → SwapSlots
  ├─ If right-click → ShowContextMenu (Use, Equip, Drop, Examine)
  └─ Show item detail in right panel
 ```
 ---
 ## WBP_JournalDocumentViewer
 **Canvas:** ScrollBox with document entries + detail view on right
 **Key Logic:**
 ```
 Construct → BPC_DocumentArchiveSystem → GetAllDocuments()
  └─ For each doc → create list item → on click → show full text + image
 ```
 ---
 ## WBP_ObjectiveDisplay
 **Canvas:** Vertical Box (top-right) — list of active objectives
 **Key Logic:**
 ```
 Bind GS_CoreGameState.OnObjectiveTagsChanged → Refresh
  └─ For each ActiveObjectiveTag → lookup DA_ObjectiveData → show title + progress
 ```
 ---
 ## WBP_NotificationToast
 **Canvas:** Border (top-center, slides in/out) → Icon + Title + Subtitle
 **Key Logic:**
 ```
 ShowToast(Title, Subtitle, Icon, Duration):
  ├─ Set text
  ├─ Play SlideIn animation
  └─ Delay(Duration) → Play SlideOut → Remove from parent
 ```
 ---
 ## WBP_ScreenEffectController
 **Canvas:** Full-screen overlay images (vignette, blood, healing, flash)
 **Key Logic:**
 ```
 PlayEffect(EffectType, Intensity, Duration):
  ├─ Switch EffectType
  │   Damage → Show red vignette, fade to Intensity
  │   Healing → Show green edge glow
  │   Death → Show black fade
  │   Flash → Show white screen
  └─ Timeline: fade in, hold, fade out
 Bind BPC_HealthSystem.OnHealthChanged → if damage → PlayEffect(Damage)
 ```
 ---
 ## WBP_AccessibilityUI
 **Canvas:** Toggles and sliders for accessibility options
 **Controls:**
 - Subtitles: On/Off + size slider
 - Colorblind Mode: Off/Protanopia/Deuteranopia/Tritanopia
 - Controller Remap: Per-platform button mapping
 - Difficulty: Story/Easy/Normal/Hard/Nightmare
 - Aim Assist: Off/Low/Medium/High
 **On change → call SS_SettingsSystem.SaveAccessibilitySettings()**
 ---
 ## WBP_DiegeticHUDFrame
 **Canvas:** Empty container that renders to a material on the player's wristwatch/helmet
 **Key Logic:**
 - This widget renders to a RenderTarget
 - The render target is assigned to the wristwatch mesh material
 - Contents show mini-HUD: health dots, ammo count, compass
 ---
 ## WBP_MenuFlowController
 **Not visual** — state machine that manages menu transitions.
 **States:** MainMenu → NewGame → Loading → InGame → Pause → Settings → Death → Credits
 **Key Logic:**
 ```
 PushMenu(MenuWidget):
  ├─ If current menu → hide
  ├─ Create new menu → add to viewport
  └─ Store in MenuStack
 PopMenu():
  ├─ Remove top menu from viewport
  └─ Restore previous menu
 OnBackPressed:
  ├─ If menu stack has entries → PopMenu
  └─ If game and no stack → Show PauseMenu
 ```
 ---
 ## WBP_CreditsScreen
 **Canvas:** ScrollBox — auto-scrolling credits text
 **Key Logic:**
 ```
 Event Construct:
  └─ Start Timeline → scroll credits text from bottom to top over 60 seconds
 OnSkip (any key press):
  └─ Jump to end → show "Thanks for Playing" → auto-transition to MainMenu
 ```
 ---
 ## Test All Widgets
 - [ ] Each widget displays in isolation (right-click → Run Widget)
 - [ ] Pause menu toggles cursor correctly
 - [ ] Settings save and persist across sessions
 - [ ] Inventory grid updates when items change
 - [ ] Notification toast animates in/out
 - [ ] Screen effects don't block input
--- a/docs/blueprints/06-ui/WBP_HUDController.asset.md
+++ b/docs/blueprints/06-ui/WBP_HUDController.asset.md
@@ -0,0 +1,72 @@
 # WBP_HUDController — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/UI/WBP_HUDController`
 > **Parent Class:** `UserWidget`
 > **Purpose:** Root HUD widget — manages all HUD sub-widgets
 ---
 ## Create This Widget
 1. Content Browser → `Content/Framework/UI/`
 2. Right-click → **User Interface → Widget Blueprint**
 3. Name: `WBP_HUDController`
 ---
 ## Designer Canvas Setup
 ```
 Canvas Panel (root)
  ├─ WBP_InteractionPromptDisplay   (bottom-center)
  ├─ WBP_ObjectiveDisplay            (top-right)
  ├─ WBP_NotificationToast           (top-center)
  ├─ HealthBar (ProgressBar)         (bottom-left)  [inline or sub-widget]
  ├─ StaminaBar (ProgressBar)        (bottom-left, below health)
  ├─ AmmoDisplay (TextBlock)         (bottom-right)
  ├─ Crosshair (Image)               (center)
  └─ WBP_DiegeticHUDFrame            (full screen, behind everything)
 ```
 ---
 ## What to Wire
 ### Event: Event Construct
 ```
 [Event Construct]
  ├─ Get Owning Player Pawn → Store as CachedPawn
  ├─ Get Pawn → GetComponentByClass(BPC_HealthSystem) → Bind OnHealthChanged
  ├─ GetComponentByClass(BPC_StaminaSystem) → Bind OnStaminaChanged
  ├─ Get GameState → Cast to GS_CoreGameState → Bind OnObjectiveTagsChanged
  └─ Get GameInstance → Cast to GI_GameFramework → Bind OnGamePhaseChanged
 ```
 ### Health Binding (Custom Event)
 ```
 [OnHealthChanged(Current, Max, Delta)]
  ├─ HealthBar → Set Percent(Current / Max)
  ├─ Branch: Delta < 0?
  │   True → Play Animation (DamageVignette)
  └─ Branch: Current <= 0?
      └─ Call WBP_ScreenEffectController → PlayDeathEffect
 ```
 ### GamePhase Binding
 ```
 [OnGamePhaseChanged(NewPhase)]
  ├─ Switch on NewPhase:
  │   MainMenu → Hide HUD
  │   InGame → Show HUD
  │   Paused → Dim HUD, show pause overlay
  │   Cutscene → Hide HUD
  │   DeathLoop → Show death screen
 ```
 ---
 ## Test It
 - [ ] PIE with player pawn: HUD displays
 - [ ] Take damage: health bar updates
 - [ ] Sprint: stamina bar drains
 - [ ] Open menu: HUD hides/disables
--- a/docs/blueprints/06-ui/WBP_InteractionPromptDisplay.asset.md
+++ b/docs/blueprints/06-ui/WBP_InteractionPromptDisplay.asset.md
@@ -0,0 +1,70 @@
 # WBP_InteractionPromptDisplay — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/UI/WBP_InteractionPromptDisplay`
 > **Parent Class:** `UserWidget`
 ---
 ## Create This Widget
 1. Content Browser → `Content/Framework/UI/`
 2. Right-click → **User Interface → Widget Blueprint**
 3. Name: `WBP_InteractionPromptDisplay`
 ---
 ## Designer Canvas
 ```
 Canvas Panel
  └─ Border (background, semi-transparent black)
       └─ Horizontal Box
            ├─ Image (key icon, e.g. "E" key)
            └─ Vertical Box
                 ├─ TextBlock "PromptText"   (e.g. "Pick Up")
                 └─ TextBlock "SubText"      (e.g. "MedKit")
 ```
 ---
 ## What to Wire
 ### Function: ShowPrompt
 ```
 Inputs: PromptText(Text), SubText(Text), KeyIcon(Texture2D), bShowHoldProgress(Boolean)
  ├─ Set PromptText = PromptText
  ├─ Set SubText = SubText
  ├─ Set KeyIcon = KeyIcon
  ├─ Branch: bShowHoldProgress?
  │   True → Show HoldProgressBar
  ├─ Set Visibility = Visible
  └─ Play Animation (FadeIn)
 ```
 ### Function: HidePrompt
 ```
  ├─ Set Visibility = Hidden
  └─ Stop All Animations
 ```
 ### Function: UpdateHoldProgress
 ```
 Input: Progress(0.0-1.0)
  └─ HoldProgressBar → Set Percent(Progress)
 ```
 ---
 ## Events to Handle
 | Event | Action |
 |-------|--------|
 | `BPC_InteractionDetector.OnFocusBegin` | ShowPrompt with object data |
 | `BPC_InteractionDetector.OnFocusEnd` | HidePrompt |
 | `BPC_InteractionDetector.OnHoldProgress` | UpdateHoldProgress |
 ---
 ## Test It
 - [ ] Look at an interactable object → prompt appears
 - [ ] Hold interact key → progress bar fills
 - [ ] Look away → prompt disappears
--- a/docs/blueprints/06-ui/WBP_MainMenu.asset.md
+++ b/docs/blueprints/06-ui/WBP_MainMenu.asset.md
@@ -0,0 +1,75 @@
 # WBP_MainMenu — Asset Implementation
 > **UE5 Asset:** `/Game/Framework/UI/WBP_MainMenu`
 > **Parent Class:** `UserWidget`
 ---
 ## Create This Widget
 1. Content Browser → `Content/Framework/UI/`
 2. Right-click → **User Interface → Widget Blueprint**
 3. Name: `WBP_MainMenu`
 ---
 ## Designer Canvas
 ```
 Canvas Panel
  └─ Vertical Box (centered)
       ├─ Image (game logo)       "LogoImage"
       ├─ Spacer
       ├─ Button "btn_NewGame"    "New Game"
       ├─ Button "btn_Continue"   "Continue"
       ├─ Button "btn_LoadGame"   "Load Game"
       ├─ Button "btn_Settings"   "Settings"
       ├─ Button "btn_Credits"    "Credits"
       └─ Button "btn_Quit"       "Quit Game"
  └─ TextBlock "VersionText"      (bottom-right) "v1.0.0"
 ```
 ---
 ## What to Wire
 ### Event: Event Construct
 ```
 [Event Construct]
  ├─ Get GameInstance → Cast to GI_GameFramework
  ├─ Get SaveManager → GetSlotManifest()
  ├─ Branch: Any slot has data?
  │   True → btn_Continue.SetIsEnabled(true)
  │   False → btn_Continue.SetIsEnabled(false)
  └─ Set Input Mode: UI + Show Cursor
 ```
 ### Button Handlers
 ```
 btn_NewGame.OnClicked:
  ├─ Call GI_GameFramework.ClearAllSessionFlags()
  ├─ Call GI_GameFramework.SetActiveSlot(new slot index)
  ├─ Call OpenLevel (first chapter map)
  └─ Set Input Mode: Game
 btn_Continue.OnClicked:
  ├─ Call SaveManager.QuickLoad()
  └─ OnLoadComplete → OpenLevel (saved chapter)
 btn_LoadGame.OnClicked:
  └─ Push WBP_LoadGameMenu to SS_UIManager stack
 btn_Settings.OnClicked:
  └─ Push WBP_SettingsMenu
 btn_Quit.OnClicked:
  └─ Quit Game (or ConsoleCommand "quit")
 ```
 ---
 ## Test It
 - [ ] Game opens at main menu → cursor visible
 - [ ] No save data → Continue grayed out
 - [ ] Click New Game → level loads → cursor hidden
 - [ ] Click Quit → game exits
--- a/docs/blueprints/07-narrative/NarrativeAssets_All.asset.md
+++ b/docs/blueprints/07-narrative/NarrativeAssets_All.asset.md
@@ -0,0 +1,108 @@
 # Narrative Systems — Asset Creation Sheet (11 assets)
 > **UE5 Path:** `Content/Framework/Narrative/`
 ---
 ## Components (attach to player pawn or GameState)
 ### BPC_NarrativeStateSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `ActiveFlags` | `Array<GameplayTag>` | Empty |
 | `CurrentChapter` | GameplayTag | Empty |
 | `CurrentPhase` | GameplayTag | Empty |
 **SetFlag(Tag):** Add to ActiveFlags → broadcast OnNarrativeFlagSet
 ### BPC_ObjectiveSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `ActiveObjectives` | `Array<GameplayTag>` | Empty |
 | `CompletedObjectives` | `Array<GameplayTag>` | Empty |
 **ActivateObjective(Tag):** → Add to Active → broadcast OnObjectiveActivated → GS_CoreGameState.AddObjective(Tag)
 ### BPC_DialoguePlaybackSystem
 | Variable | Type |
 |----------|------|
 | `DialogueQueue` | `Array<FDialogueLine>` |
 | `bIsPlaying` | Boolean |
 | `bAutoAdvance` | Boolean |
 **PlayDialogue(DialogueData):** → Show subtitles → play VO → advance queue
 ### BPC_DialogueChoiceSystem
 | Variable | Type |
 |----------|------|
 | `CurrentChoices` | `Array<FDialogueChoice>` |
 | `SelectedChoiceIndex` | Integer |
 **PresentChoices(Choices):** → Show WBP_DialogueChoice widget → wait for selection → return
 ### BPC_BranchingConsequenceSystem
 | Variable | Type |
 |----------|------|
 | `PendingConsequences` | `Array<FDialogueChoice>` |
 **ExecuteConsequence(Choice):** → Grant items, set narrative flags, change relationships, trigger cutscenes
 ### BPC_TrialScenarioSystem
 | Variable | Type | Default |
 |----------|------|---------|
 | `TrialTimer` | Float | `0.0` |
 | `bTrialActive` | Boolean | `false` |
 | `TrialSuccessThreshold` | Float | `60.0` |
 ### BPC_CutsceneBridge
 | Variable | Type |
 |----------|------|
 | `CurrentCutscene` | `DA_CutsceneData` |
 | `bCutscenePlaying` | Boolean |
 **PlayCutscene(Data):** → Set phase to Cutscene → play Sequence → on finish → restore phase
 ### BPC_LoreUnlockSystem
 | Variable | Type |
 |----------|------|
 | `UnlockedLore` | `Array<GameplayTag>` |
 **UnlockLore(Tag):** → Add to unlocked → show notification → add to journal
 ### BPC_EndingAccumulator
 | Variable | Type |
 |----------|------|
 | `EndingConditions` | `TMap<GameplayTag, Float>` |
 | `DominantEnding` | GameplayTag |
 ---
 ## Data Assets (create instances per content)
 | Asset | Purpose |
 |-------|---------|
 | `DA_DialogueData` | Dialogue lines, speaker, VO, conditions |
 | `DA_CutsceneData` | Level sequence, milestone flags, skip policy |
 | `DA_ObjectiveData` | Title, description, prerequisites, rewards |
 | `DA_TrialData` | Timer, success conditions, failure consequences |
 ---
 ## Actor — BP_NarrativeTriggerVolume
 **Parent:** `TriggerVolume`
 | Variable | Type |
 |----------|------|
 | `TriggerTag` | GameplayTag |
 | `bTriggerOnce` | Boolean |
 | `NarrativeActions` | `Array<S_NarrativeAction>` |
 **OnOverlapBegin:** → Execute narrative actions (set flag, start dialogue, activate objective, play cutscene)
 ---
 ## Test These
 - [ ] Walk into trigger → dialogue starts → subtitles show
 - [ ] Dialogue choices appear → select option → consequence fires
 - [ ] Objective activates → shows in HUD objective display
 - [ ] Trial scenario starts → timer counts down → succeed/fail
--- a/docs/blueprints/08-weapons/Weapons_AI_Adaptive_QuickSheet.asset.md
+++ b/docs/blueprints/08-weapons/Weapons_AI_Adaptive_QuickSheet.asset.md
@@ -0,0 +1,107 @@
 # Weapons, AI & Adaptive — Asset Creation Sheet (31 assets)
 > **UE5 Path:** `Content/Framework/Weapons/`, `Content/Framework/AI/`, `Content/Framework/Adaptive/`
 ---
 ## Weapons (08-weapons — 10 remaining BP assets)
 ### BP_WeaponBase (Actor)
 **Parent:** `Actor` → Add SkeletalMesh, ArrowComponent (muzzle)
 | Variable | Type | Default |
 |----------|------|---------|
 | `WeaponData` | `DA_ItemData` | Assign |
 | `AmmoLoaded` | Integer | `0` |
 | `FireMode` | GameplayTag | `Framework.Combat.FireMode.SemiAuto` |
 | `MuzzleFlashFX` | ParticleSystem | Assign |
 | `FireSound` | SoundBase | Assign |
 **Implements:** `I_Interactable`, `I_UsableItem`
 ### BP Components (attach to player/enemy pawns)
 | Component | Key Variables |
 |-----------|--------------|
 | `BPC_AmmoComponent` | `ReserveAmmo`(Int), `MaxReserve`(Int), `AmmoType`(GameplayTag) |
 | `BPC_CombatFeedbackComponent` | `bShowHitMarker`(Bool), `HitMarkerDuration`(Float) |
 | `BPC_DamageReceptionSystem` | ✅ C++ done — attach directly |
 | `BPC_DeathCauseTracker` | `LastDamageType`(GameplayTag), `LastKiller`(Actor) |
 | `BPC_FirearmSystem` | `CurrentFireMode`(GameplayTag), `bChamberEmpty`(Bool) |
 | `BPC_HitReactionSystem` | `FlinchAnimation`(AnimMontage), `KnockdownAnimation`(AnimMontage) |
 | `BPC_MeleeSystem` | `ComboCount`(Int), `CurrentComboWindow`(Float) |
 | `BPC_RecoilSystem` | `RecoilPattern`(CurveVector), `RecoilRecoverySpeed`(Float) |
 | `BPC_ReloadSystem` | `ReloadTime`(Float), `bTacticalReload`(Bool) |
 | `BPC_ShieldDefenseSystem` | `ShieldHealth`(Float), `BlockAngle`(Float) |
 ---
 ## AI (09-ai — 9 BP assets)
 ### BP_EnemyBase (Character)
 **Parent:** `Character` → Add SkeletalMesh, Capsule, AI Perception
 | Variable | Type | Default |
 |----------|------|---------|
 | `EnemyData` | `DA_EncounterData` | Assign |
 | `AlertLevel` | GameplayTag | `Framework.AI.Alert.Unaware` |
 | `Archetype` | GameplayTag | `Framework.AI.Archetype.Patrol` |
 ### Components
 | Component | Purpose |
 |-----------|---------|
 | `BPC_AlertSystem` | Suspicious → Alerted → Combat state machine |
 | `BPC_AIStateMachine` | Patrol/Search/Combat/Flee transitions |
 | `BPC_AIMemorySystem` | Last known locations, threat history |
 | `BPC_AIPerceptionSystem` | Sight, hearing, damage sense |
 | `BPC_BehaviourVariantSelector` | Weighted random behavior selection from DA_BehaviourVariant set |
 ### Other AI Assets
 | Asset | Type | Purpose |
 |-------|------|---------|
 | `BP_PatrolPath` | Actor + Spline | Patrol waypoints |
 | `AI_BaseAgentController` | AIController | Behavior tree runner |
 | `BB_AgentBoard` | Blackboard | AI keys (Target, LastLocation, AlertLevel, etc.) |
 ---
 ## Adaptive (10-adaptive — 13 BP assets)
 ### Components
 | Component | Purpose |
 |-----------|---------|
 | `BPC_DifficultyManager` | Dynamic difficulty scaling based on player metrics |
 | `BPC_FearSystem` | AI + player fear states, cower, flee |
 | `BPC_PerformanceScaler` | LOD, spawn distance, effect quality |
 | `BPC_ProceduralEncounter` | Difficulty-based spawn group generation |
 | `BPC_AdaptiveEnvironmentDirector` | Room mutation, event coordination |
 | `BPC_AtmosphereStateController` | Room tone, tension, mood |
 | `BPC_AudioAtmosphereController` | [DEPRECATED — use SS_AudioManager] |
 | `BPC_LightEventController` | Flicker, dim, color shift, strobe |
 | `BPC_MemoryDriftSystem` | Visual/audio/dialogue distortions (stress-based) |
 | `BPC_PacingDirector` | Intensity bands, encounter frequency, music |
 | `BPC_PlaystyleClassifier` | Aggressive/Stealthy/Explorer/Balanced |
 | `BPC_RareEventSystem` | Weighted rare event selection + cooldown |
 | `BPC_ScareEventSystem` | Jump scares, anticipation, recovery |
 | `SS_AudioManager` | GameInstanceSubsystem — MetaSounds entry point |
 | `BP_RoomAudioZone` | TriggerVolume — auto-switches room reverb |
 ---
 ## Test Weapons
 - [ ] Pick up weapon → attaches to hand socket
 - [ ] Fire → muzzle flash + recoil + ammo count decreases
 - [ ] Empty magazine → auto-reload (or click Reload)
 - [ ] Melee → combo counter increments
 ## Test AI
 - [ ] Patrol path → enemy walks waypoints
 - [ ] Player enters sight → alert level rises → chase begins
 - [ ] Player hides → enemy loses sight → searches last known location
 - [ ] Combat → enemy uses behavior variant (flanking, cover, rush)
 ## Test Adaptive
 - [ ] Player dies frequently → difficulty decreases (fewer enemies, more health)
 - [ ] Player excels → difficulty increases
 - [ ] Stress high → memory drift distortions activate
 - [ ] Scare event triggers → jump scare sound + visual plays
--- a/docs/blueprints/11-meta/Meta_Settings_Polish_DataAssets.asset.md
+++ b/docs/blueprints/11-meta/Meta_Settings_Polish_DataAssets.asset.md
@@ -0,0 +1,119 @@
 # Meta, Settings & Polish — Asset Creation Sheet (13 assets)
 > **UE5 Path:** `Content/Framework/Achievements/`, `Content/Framework/Settings/`, `Content/Framework/Polish/`
 ---
 ## Meta (11-meta — 2 assets)
 ### BPC_ProgressStatTracker
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `TotalPlaytime` | Float | `0.0` |
 | `TotalKills` | Integer | `0` |
 | `TotalDeaths` | Integer | `0` |
 | `CollectiblesFound` | Integer | `0` |
 | `EndingsUnlocked` | `Array<GameplayTag>` | Empty |
 | `DifficultyCompleted` | `Array<GameplayTag>` | Empty |
 ### SS_AchievementSystem
 **Parent:** `GameInstanceSubsystem` — auto-created by GameInstance
 | Variable | Type |
 |----------|------|
 | `UnlockedAchievements` | `Array<GameplayTag>` |
 | `PendingNotifications` | `Array<GameplayTag>` |
 **UnlockAchievement(Tag):** → Check platform API → if not already unlocked → unlock → show toast → save
 ---
 ## Settings (12-settings — 2 assets)
 ### BPC_AccessibilitySettings
 **Attach to:** Player pawn
 | Variable | Type | Default |
 |----------|------|---------|
 | `bSubtitlesEnabled` | Boolean | `true` |
 | `SubtitleSize` | Float | `1.0` |
 | `ColorblindMode` | Integer | `0` |
 | `bAimAssist` | Boolean | `true` |
 | `AimAssistStrength` | Float | `0.5` |
 | `DifficultyLevel` | Integer | `2` |
 ### SS_SettingsSystem
 **Parent:** `GameInstanceSubsystem` — auto-created
 | Variable | Type |
 |----------|------|
 | `VideoSettings` | `S_VideoSettings` |
 | `AudioSettings` | `S_AudioSettings` |
 | `ControlSettings` | `S_ControlSettings` |
 | `AccessibilitySettings` | `S_AccessibilitySettings` |
 **ApplyAndSave():** → Write to config file → broadcast OnSettingsApplied
 ---
 ## Polish (13-polish — 9 assets)
 ### Components
 | Component | Purpose |
 |-----------|---------|
 | `BPC_AnalyticsTracker` | Event tracking, session metrics, telemetry |
 | `BPC_DevCheatManager` | God mode, noclip, give item, teleport |
 | `BPC_ErrorHandler` | Crash logging, error display, recovery |
 | `BPC_FPSCounter` | FPS display, min/max/avg tracking |
 | `BPC_LoadingScreen` | Progress bar, tips, background |
 | `BPC_TutorialSystem` | Contextual prompts, progression, dismiss |
 ### Widgets
 | Widget | Purpose |
 |--------|---------|
 | `WBP_CreditsScreen` | Auto-scroll credits, skip, post-credit scene |
 | `WBP_DebugMenu` | State viewer, log, performance, cheats |
 | `WBP_SplashScreen` | Studio/engine logo, skip |
 ---
 ## Data Assets — Remaining (14-data-assets — 16 total)
 Create Data Asset instances (not Blueprint children) for all content definitions.
 | Asset | Purpose | Key Properties |
 |-------|---------|---------------|
 | `DA_AdaptationRule` | Difficulty adaptation | MetricThreshold, Action, ScaleFactor |
 | `DA_AtmosphereProfile` | Room atmosphere | AudioLayer, LightSettings, FogSettings, PostProcess |
 | `DA_BehaviourVariant` | AI behavior | AttackPattern, PatrolStyle, AggressionLevel |
 | `DA_EncounterData` | Enemy group | EnemyTypes, SpawnRules, DifficultyTier |
 | `DA_EquipmentConfig` | Weapon/armor stats | DamageTypeResistances, Durability, Weight |
 | `DA_HapticProfile` | Force feedback | RumblePattern, Intensity, Duration |
 | `DA_InteractionData` | Interaction def | PromptText, Duration, Icon, Conditions |
 | `DA_ObjectiveData` | Quest def | Title, Description, Prerequisites, Rewards |
 | `DA_PuzzleData` | Puzzle def | Solution, Steps, Hints, Rewards |
 | `DA_RareEvent` | Rare event | Weight, Conditions, Effects, Cooldown |
 | `DA_RoomMutation` | Room change | LayoutChange, ObjectSwap, LightChange |
 | `DA_ScareEvent` | Scare def | Type, Anticipation, Payoff, Recovery |
 | `DA_InputMappingProfile` | Per-platform bindings | PC/Xbox/PS5 key arrays |
 | `DA_AudioSettings` | Audio config | Bus volumes, ducking, pool limits |
 | `DA_RoomAcousticPreset` | Room acoustics | Reverb, Occlusion, Reflection (7 presets) |
 ### How to Create Each Data Asset
 1. Right-click → **Miscellaneous → Data Asset**
 2. Class: `DA_{Type}` (if C++) or `PrimaryDataAsset`
 3. Name: `DA_{Type}_{Name}` (e.g. `DA_ObjectiveData_Chapter1_FindKey`)
 4. Fill properties per the spec file in `docs/blueprints/14-data-assets/`
 ---
 ## Test Meta/Settings/Polish
 - [ ] Unlock achievement → toast notification appears → saved to platform
 - [ ] Change settings → persist after restart
 - [ ] Press F1 → debug menu opens
 - [ ] Loading screen shows between levels with progress bar
 - [ ] Tutorial popups appear for first-time actions
--- a/docs/blueprints/15-input/IA_IMC_All.asset.md
+++ b/docs/blueprints/15-input/IA_IMC_All.asset.md
@@ -0,0 +1,121 @@
 # IA_* — Input Actions + IMC_* — Input Mapping Contexts
 > **UE5 Path:** `Content/Framework/Input/Actions/` + `Content/Framework/Input/Contexts/`
 > **Plugin Required:** Enhanced Input (enabled in project plugins)
 ---
 ## Prerequisites
 1. **Project Settings → Plugins → Enhanced Input** → Enabled ✓
 2. Restart editor after enabling
 ---
 ## Input Actions — Create All (17 assets)
 ### Gameplay Actions
 | Asset Name | Value Type | Description |
 |-----------|-----------|-------------|
 | `IA_Move` | `Axis2D` | WASD / Left Stick movement |
 | `IA_Look` | `Axis2D` | Mouse / Right Stick camera |
 | `IA_Jump` | `Digital (bool)` | Jump / Vault |
 | `IA_Sprint` | `Digital (bool)` | Sprint (hold) |
 | `IA_Crouch` | `Digital (bool)` | Toggle crouch |
 | `IA_Interact` | `Digital (bool)` | Primary interact (E / X) |
 | `IA_InteractHold` | `Digital (bool)` | Hold interaction (hold E) |
 | `IA_Reload` | `Digital (bool)` | Reload weapon |
 | `IA_Fire` | `Digital (bool)` | Primary fire |
 | `IA_AimDownSights` | `Digital (bool)` | Aim (hold) |
 | `IA_Melee` | `Digital (bool)` | Melee attack |
 | `IA_UseItem` | `Digital (bool)` | Use equipped/quick-slot item |
 | `IA_ToggleInventory` | `Digital (bool)` | Open/close inventory |
 | `IA_ToggleJournal` | `Digital (bool)` | Open/close journal |
 | `IA_Pause` | `Digital (bool)` | Pause menu |
 | `IA_Hide` | `Digital (bool)` | Enter/exit hiding |
 | `IA_Peek` | `Digital (bool)` | Peek while hiding |
 ### How to Create Each
 1. Content Browser → `Content/Framework/Input/Actions/`
 2. Right-click → **Input → Input Action**
 3. Name: `IA_{Action}`
 4. Open the asset → set **Value Type** per the table above
 5. Optionally add **Triggers** (Tap, Hold, Pressed, Released)
 6. Optionally add **Modifiers** (Negate, Dead Zone, Swizzle Axis)
 ### Common Trigger/Modifier Setup
 ```
 IA_Interact:    Trigger: Pressed
 IA_InteractHold:  Trigger: Hold (HoldTimeThreshold = 0.5)
 IA_Sprint:      Trigger: Hold
 IA_Crouch:      Trigger: Pressed (toggle behavior in code)
 IA_Fire:        Trigger: Pressed + Trigger: Hold (for auto-fire)
 IA_AimDownSights: Trigger: Hold
 IA_Pause:       Trigger: Pressed
 ```
 ---
 ## Input Mapping Contexts — Create All (6 assets)
 | Asset Name | Priority | Contains These Actions | When Active |
 |-----------|----------|----------------------|-------------|
 | `IMC_Default` | 0 | Move, Look, Jump, Sprint, Crouch, Interact, InteractHold, Reload, Fire, AimDownSights, Melee, UseItem, ToggleInventory, ToggleJournal, Pause | Always (lowest priority) |
 | `IMC_Hiding` | 5 | Hide, Peek (overrides some IMC_Default) | While hidden |
 | `IMC_WristwatchUI` | 10 | Interact (re-mapped to wristwatch), Look | Wristwatch mode |
 | `IMC_Inspection` | 20 | Look (rotation only), Interact (exit inspect) | 3D inspect mode |
 | `IMC_UI` | 100 | Pause (close), Interact (confirm) | Any menu open |
 | `IMC_Vehicle` | 3 | Move (vehicle), Look, Interact (exit) | While in vehicle |
 ### How to Create Each
 1. Content Browser → `Content/Framework/Input/Contexts/`
 2. Right-click → **Input → Input Mapping Context**
 3. Name: `IMC_{Context}`
 4. Open → **Add Mapping** for each action in the table
 5. For each mapping, select the `IA_` asset and assign a key binding
 ### Default Key Bindings (PC — IMC_Default)
 | Action | Primary Key | Secondary Key |
 |--------|------------|---------------|
 | `IA_Move` | `W/A/S/D` | Left Stick |
 | `IA_Look` | `Mouse XY` | Right Stick |
 | `IA_Jump` | `Space` | `A` (gamepad) |
 | `IA_Sprint` | `Left Shift` | Left Stick Click |
 | `IA_Crouch` | `Left Ctrl` | `B` (gamepad) |
 | `IA_Interact` | `E` | `X` (gamepad) |
 | `IA_Reload` | `R` | `Y` (gamepad) |
 | `IA_Fire` | `Left Mouse` | Right Trigger |
 | `IA_AimDownSights` | `Right Mouse` | Left Trigger |
 | `IA_Melee` | `V` | Right Stick Click |
 | `IA_UseItem` | `Q` | `D-Pad Up` |
 | `IA_ToggleInventory` | `Tab` | `Select` |
 | `IA_ToggleJournal` | `J` | `D-Pad Left` |
 | `IA_Pause` | `Escape` | `Start` |
 ---
 ## Context Priority System
 ```
 IMC_UI (100)           ← Highest — blocks everything
 IMC_Inspection (20)
 IMC_WristwatchUI (10)
 IMC_Hiding (5)
 IMC_Vehicle (3)
 IMC_Default (0)        ← Lowest — always active
 ```
 When a higher-priority context is pushed, conflicting inputs from lower contexts are overridden. Non-conflicting inputs still pass through.
 ---
 ## Test It
 - [ ] All 17 IA_ assets created with correct Value Types
 - [ ] All 6 IMC_ assets created with correct mappings
 - [ ] PIE: WASD moves character, mouse looks around, E interacts
 - [ ] Push IMC_Hiding → IMC_Default actions blocked except those also in IMC_Hiding
 - [ ] Open inventory → IMC_UI pushes → cursor appears → game inputs blocked
--- a/docs/blueprints/16-state/StateAssets_All.asset.md
+++ b/docs/blueprints/16-state/StateAssets_All.asset.md
@@ -0,0 +1,152 @@
 # State Management Assets — Enums, Structs, Data Asset
 > **UE5 Path:** `Content/Framework/State/`
 > **Assets:** 4 Enums + 3 Structs + 1 Data Asset + 1 Component
 ---
 ## Enums — Create All (4 assets)
 ### E_PlayerActionState (42 values)
 1. Content Browser → `Content/Framework/State/`
 2. Right-click → **Blueprint → Enumeration**
 3. Name: `E_PlayerActionState`
 **Values to Add:**
 ```
 Idle, Walking, Sprinting, Crouching, Jumping, Falling, Landing,
 Sliding, Vaulting, Mantling, Climbing, Swimming, Crawling,
 Firing, Aiming, Reloading, Melee, Blocking, Throwing,
 Interacting, Inspecting, UsingItem, ConsumingItem,
 Hiding, Peeking, HoldingBreath, Lockpicking, Hacking,
 Dialoguing, Reading, Examining, Crafting,
 Dead, Dying, Unconscious, Staggered, KnockedDown,
 CutsceneBound, VoidSpace, Menu, Inventory, Journal
 ```
 ### E_OverlayState (18 values)
 1. Name: `E_OverlayState`
 **Values:**
 ```
 None, Aiming, Firing, Reloading, MeleeAttack, Blocking,
 UsingItem, Inspecting, Interacting, Throwing,
 HoldingBreath, Peeking, Dialoguing, Injured,
 Staggered, Carrying, WristwatchActive, MapActive
 ```
 ### E_PlayerVitalSignals (5 values)
 1. Name: `E_PlayerVitalSignals`
 **Values:**
 ```
 Calm, Elevated, Stressed, Panic, Critical
 ```
 ### E_ActionRequestResult (8 values)
 1. Name: `E_ActionRequestResult`
 **Values:**
 ```
 Granted, Denied, BlockedByForce, AlreadyActive,
 InvalidState, RequesterNotFound, CooldownActive, VitalThreshold
 ```
 ---
 ## Structs — Create All (3 assets)
 ### S_StateChangeRequest
 1. Content Browser → `Content/Framework/State/`
 2. Right-click → **Blueprint → Structure**
 3. Name: `S_StateChangeRequest`
 | Field | Type |
 |-------|------|
 | `RequestedState` | `GameplayTag` |
 | `Requester` | `Actor` (Object Reference) |
 | `Priority` | `Integer` |
 | `Reason` | `String` |
 | `Timestamp` | `Float` |
 ### S_StateGatingRule
 1. Name: `S_StateGatingRule`
 | Field | Type |
 |-------|------|
 | `ActionTag` | `GameplayTag` |
 | `BlockedByStates` | `Array<GameplayTag>` |
 | `RequiresStates` | `Array<GameplayTag>` |
 | `BlockedByOverlays` | `Array<GameplayTag>` |
 | `bRequiresAuthority` | `Boolean` |
 | `CooldownSeconds` | `Float` |
 | `RulePriority` | `Integer` |
 ### S_ActionPermissionResult
 1. Name: `S_ActionPermissionResult`
 | Field | Type |
 |-------|------|
 | `bPermitted` | `Boolean` |
 | `ResultCode` | `E_ActionRequestResult` |
 | `BlockingState` | `GameplayTag` |
 | `BlockReason` | `String` |
 ---
 ## Data Asset — DA_StateGatingTable
 ### Create
 1. Content Browser → `Content/Framework/State/`
 2. Right-click → **Miscellaneous → Data Asset**
 3. Class: `PrimaryDataAsset`
 4. Name: `DA_StateGatingTable`
 ### Variables to Add
 | Variable | Type | Default |
 |----------|------|---------|
 | `GatingRules` | `Array<S_StateGatingRule>` | Empty — populate below |
 | `ForceStackRules` | `Array<S_StateGatingRule>` | Empty |
 ### Populate GatingRules (37 action rules — key examples)
 | Action | Blocked By |
 |--------|-----------|
 | `Framework.State.Action.Sprint` | Crouching, Aiming, Firing, Injured |
 | `Framework.State.Action.Fire` | Sprinting, Reloading, Dead, Menu |
 | `Framework.State.Action.Reload` | Sprinting, Firing, Melee, Dead |
 | `Framework.State.Action.Jump` | Crouching, Dead, CutsceneBound |
 | `Framework.State.Action.Interact` | Sprinting, Firing, Dead, Menu |
 | `Framework.State.Action.Hide` | Sprinting, Firing, Carrying |
 | `Framework.State.Action.Melee` | Reloading, Inspecting, Dead |
 | `Framework.State.Action.UseItem` | Dead, Staggered, CutsceneBound |
 | `Framework.State.Action.Crouch` | Sprinting, Falling, Vaulting |
 | `Framework.State.Action.Inspect` | Sprinting, Hiding, Dead, Menu |
 | `Framework.State.Action.Dialogue` | Sprinting, Firing, Hiding, Dead |
 | `Framework.State.Action.Vault` | Crouching, Aiming, Firing, Carrying |
 | `Framework.State.Action.Aim` | Sprinting, Reloading, Melee, Dead |
 | `Framework.State.Action.Menu` | Dead, CutsceneBound (always permitted otherwise) |
 | `Framework.State.Action.Dead` | Always permitted (force-state — overrides everything) |
 ---
 ## Component — BPC_StateManager
 Already covered in C++ (`Source/Framework/Public/Player/BPC_StateManager.h`).
 ### Attach to Pawn
 1. Open player pawn Blueprint
 2. **Add Component → BPC_StateManager**
 3. In Details → `Gating Table` → assign `DA_StateGatingTable`
 4. Set `Default Action State` → `Framework.State.Action.Idle`
 ---
 ## Test It
 - [ ] All 4 enums created with correct values
 - [ ] All 3 structs created with correct fields
 - [ ] `DA_StateGatingTable` populated with 37 rules
 - [ ] PIE: `IsActionPermitted(SprintTag)` returns `false` when crouching
 - [ ] `RequestStateChange(Fire)` returns `Granted` when idle
 - [ ] `ForceStateChange(Dead)` → `IsActionPermitted(AnyTag)` returns `false`
 - [ ] `RestorePreviousState()` → previous state restored
--- a/docs/checklists/cpp-blueprint-status.md
+++ b/docs/checklists/cpp-blueprint-status.md
@@ -0,0 +1,235 @@
 # C++ & Blueprint Status Checklist — All 135 Systems
 **Version:** 1.0 | **Generated:** 2026-05-20
 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.
 ---
 ## Legend
 | Symbol | Meaning |
 |--------|---------|
 | ✅ | **Done** — C++ files written, BP spec complete |
 | 🟡 | **Partial** — C++ stub (references siblings, needs subsystem wiring) |
 | 🔵 | **BP Spec Only** — Full Blueprint spec exists, no C++ written |
 | ⬜ | **Content Asset** — Create Data Asset/Table instances (not code) |
 | ❌ | **Not Started** — Spec exists but asset not created |
 Abbreviations:
 - **C++ H/CPP** = C++ header and source files exist in `Source/Framework/`
 - **BP Spec** = Blueprint specification file exists in `docs/blueprints/`
 - **BP Asset** = Blueprint asset to create in UE5 Content Browser
 - **MI Guide** = Manual Implementation Guide (node-by-node) in spec file
 ---
 ## Phase 0: Foundation (01-core — 7 systems)
 | # | System | C++ H/CPP | BP Spec | BP Asset to Create | Status |
 |---|--------|-----------|---------|--------------------|--------|
 | 01 | `DA_GameTagRegistry` | ✅ `Core/DA_GameTagRegistry` | ✅ `01_DA_GameTagRegistry.md` | Data Asset instance: `DA_GameTagRegistry` (assign TagDataTables) | ✅ |
 | 02 | `FL_GameUtilities` | ✅ `Core/FL_GameUtilities` | ✅ `02_FL_GameUtilities.md` | None (static library) | ✅ |
 | 03 | `I_InterfaceLibrary` | ✅ `Core/I_InterfaceLibrary.h` | ✅ `03_I_InterfaceLibrary.md` | None (implement on actors) | ✅ |
 | 04 | `GI_GameFramework` | ✅ `Core/GI_GameFramework` | ✅ `04_GI_GameFramework.md` | **BP_GameFramework** (GameInstance child) | ✅ |
 | 05 | `GM_CoreGameMode` | ✅ `Core/GM_CoreGameMode` | ✅ `05_GM_CoreGameMode.md` | **BP_CoreGameMode** (GameMode child) | ✅ |
 | 06 | `GS_CoreGameState` | ✅ `Core/GS_CoreGameState` | ✅ `06_GS_CoreGameState.md` | **BP_CoreGameState** (GameState child) | ✅ |
 | 07 | `DA_ItemData` | ✅ `Inventory/DA_ItemData` | ✅ `07_DA_ItemData.md` | Data Asset instances: `DA_Item_*` per item | ✅ |
 | — | `GI_StarterGameInstance` | 🔵 (superseded by 04) | ✅ `GI_StarterGameInstance.md` | **BP_StarterGameInstance** (or skip, use 04) | 🟡 |
 ### Data Tables (01-core root)
 | Asset | Status |
 |-------|--------|
 | `DT_Tags_Player.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Interaction.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Item.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Narrative.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_AI.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Save.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Environment.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Combat.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_State.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Audio.csv` | ⬜ Create Data Table, import CSV |
 | `DT_Tags_Achievement.csv` | ⬜ Create Data Table, import CSV |
 ---
 ## Phase 1: Player Core (02-player — 8 systems)
 | # | 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 | 🔵 |
 | 09 | `BPC_StaminaSystem` | 🔵 BP-only | ✅ `09_BPC_StaminaSystem.md` | BP child → attach to pawn | 🔵 |
 | 10 | `BPC_StressSystem` | 🔵 BP-only | ✅ `10_BPC_StressSystem.md` | BP child → attach to pawn | 🔵 |
 | 11 | `BPC_MovementStateSystem` | 🔵 BP-only | ✅ `11_BPC_MovementStateSystem.md` | BP child → 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 | 🔵 |
 ---
 ## Phase 2-14: All Remaining Systems
 ### Interaction (03-interaction — 8 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 16 | `BPC_InteractionDetector` | 🔵 | ✅ | BP child |
 | 17 | `I_HidingSpot` | 🔵 | ✅ | Implement on BP actors |
 | 18 | `BPC_DiegeticDisplay` | 🔵 | ✅ | BP child |
 | 19 | `BP_DoorActor` | 🔵 | ✅ | BP actor child |
 | 20 | `BP_PuzzleDeviceActor` | 🔵 | ✅ | BP actor child |
 | 21 | `BPC_ContextualTraversalSystem` | 🔵 | ✅ | BP child |
 | 22 | `BPC_PhysicsDragSystem` | 🔵 | ✅ | BP child |
 | 23 | `BPC_UsableWorldObjectSystem` | 🔵 | ✅ | BP child |
 ### Inventory (04-inventory — 11 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 24 | `BPC_ContainerInventory` | 🔵 | ✅ | BP child |
 | 25 | `BP_ItemPickup` | 🔵 | ✅ | BP actor child |
 | 26 | `BPC_ActiveItemSystem` | 🔵 | ✅ | BP child |
 | 27 | `BPC_CollectibleTracker` | 🔵 | ✅ | BP child |
 | 28 | `BPC_ConsumableSystem` | 🔵 | ✅ | BP child |
 | 29 | `BPC_DocumentArchiveSystem` | 🔵 | ✅ | BP child |
 | 30 | `BPC_EquipmentSlotSystem` | 🔵 | ✅ | BP child |
 | 31 | `BPC_InventorySystem` | ✅ `Inventory/BPC_InventorySystem` | ✅ | None (use C++ component directly) |
 | 32 | `BPC_ItemCombineSystem` | 🔵 | ✅ | BP child |
 | 33 | `BPC_JournalSystem` | 🔵 | ✅ | BP child |
 | 34 | `BPC_KeyItemSystem` | 🔵 | ✅ | BP child |
 ### Save/Load (05-saveload — 9 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 35 | `SS_SaveManager` | ✅ `Save/SS_SaveManager` | ✅ | None (auto-created subsystem) |
 | 36 | `I_Persistable` | ✅ `Core/I_InterfaceLibrary.h` | ✅ | Implement on actors |
 | 37 | `BP_Checkpoint` | 🔵 | ✅ | BP actor child |
 | 38 | `BPC_AltDeathSpaceSystem` | 🔵 | ✅ | BP child |
 | 39 | `BPC_DeathHandlingSystem` | 🔵 | ✅ | BP child |
 | 40 | `BPC_PersistentCorpseSystem` | 🔵 | ✅ | BP child |
 | 41 | `BPC_PersistentWorldStateRecorder` | 🔵 | ✅ | BP child |
 | 42 | `BPC_PlayerRespawnSystem` | 🔵 | ✅ | BP child |
 | 43 | `BPC_RunHistoryTracker` | 🔵 | ✅ | BP child |
 ### UI (06-ui — 14 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 44 | `SS_UIManager` | 🔵 | ✅ | BP child (auto-created subsystem) |
 | 45 | `WBP_AccessibilityUI` | 🔵 | ✅ | Widget BP |
 | 46 | `WBP_DiegeticHUDFrame` | 🔵 | ✅ | Widget BP |
 | 47 | `WBP_HUDController` | 🔵 | ✅ | Widget BP |
 | 48 | `WBP_InteractionPromptDisplay` | 🔵 | ✅ | Widget BP |
 | 49 | `WBP_InventoryMenu` | 🔵 | ✅ | Widget BP |
 | 50 | `WBP_JournalDocumentViewer` | 🔵 | ✅ | Widget BP |
 | 51 | `WBP_MainMenu` | 🔵 | ✅ | Widget BP |
 | 52 | `WBP_MenuFlowController` | 🔵 | ✅ | Widget BP |
 | 53 | `WBP_NotificationToast` | 🔵 | ✅ | Widget BP |
 | 54 | `WBP_ObjectiveDisplay` | 🔵 | ✅ | Widget BP |
 | 55 | `WBP_PauseMenu` | 🔵 | ✅ | Widget BP |
 | 56 | `WBP_ScreenEffectController` | 🔵 | ✅ | Widget BP |
 | 57 | `WBP_SettingsMenu` | 🔵 | ✅ | Widget BP |
 ### Narrative (07-narrative — 11 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 58-68 | All 11 systems | 🔵 | ✅ | BP children + DA instances |
 ### Weapons (08-weapons — 11 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 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) |
 | 73 | `BPC_DeathCauseTracker` | 🔵 | ✅ | BP child |
 | 74 | `BPC_FirearmSystem` | 🔵 | ✅ | BP child |
 | 75 | `BPC_HitReactionSystem` | 🔵 | ✅ | BP child |
 | 76 | `BPC_MeleeSystem` | 🔵 | ✅ | BP child |
 | 77 | `BPC_RecoilSystem` | 🔵 | ✅ | BP child |
 | 78 | `BPC_ReloadSystem` | 🔵 | ✅ | BP child |
 | 79 | `BPC_ShieldDefenseSystem` | 🔵 | ✅ | BP child |
 ### AI (09-ai — 9 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 80-88 | All 9 systems | 🔵 | ✅ | BP children |
 ### Adaptive (10-adaptive — 15 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 89-101 | All 13 core | 🔵 | ✅ | BP children |
 | 132 | `SS_AudioManager` | 🔵 | ✅ | BP child (auto-created subsystem) |
 | 133 | `BP_RoomAudioZone` | 🔵 | ✅ | BP actor child |
 ### Meta, Settings, Polish (11-13 — 13 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 102-114 | All 13 systems | 🔵 | ✅ | BP children + widget BPs |
 ### Data Assets (14-data-assets — 16 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 115-127, 129, 134-135 | All 16 systems | 🔵 | ✅ | ⬜ Data Asset instances (per content item) |
 ### Input + State (15-16 — 3 systems)
 | # | System | C++ | BP Spec | BP Asset |
 |---|--------|-----|---------|----------|
 | 128 | `SS_EnhancedInputManager` | ✅ `Input/SS_EnhancedInputManager` | ✅ | None (auto-created subsystem) |
 | 130 | `BPC_StateManager` | ✅ `Player/BPC_StateManager` | ✅ | None (use C++ component) |
 | 131 | `DA_StateGatingTable` | 🔵 | ✅ | ⬜ Data Asset instance (37 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 `DA_GameTagRegistry` Data Asset, assign TagDataTables
 - [ ] Create `BP_GameFramework` (child of `GI_GameFramework`), assign TagRegistry
 - [ ] Create `BP_CoreGameMode` (child of `GM_CoreGameMode`), set in Project Settings
 - [ ] Create `BP_CoreGameState` (child of `GS_CoreGameState`), set in GameMode defaults
 - [ ] Create `BP_CorePlayerController` + `BP_CorePlayerState` (BP specs 08 area)
 - [ ] Create `DA_ItemData` instances for initial items (weapons, consumables)
 ### Player Pawn Setup
 - [ ] Create player pawn BP with GASP
 - [ ] Add `BPC_StateManager` component → assign GatingTable
 - [ ] Add `BPC_InventorySystem` component → set grid size
 - [ ] Add `BPC_DamageReceptionSystem` component → set thresholds
 - [ ] Add remaining 76 `BPC_*` BP children as needed
 ### Data Asset Content
 - [ ] Create `DA_StateGatingTable` instance with 37 rules
 - [ ] Create `DA_EquipmentConfig` instance(s) for armor/weapons
 - [ ] Create `DA_AudioSettings`, `DA_RoomAcousticPreset` instances
 - [ ] Create remaining `DA_*` instances per project content
 ---
 *Status Checklist v1.0 — Updated 2026-05-20. Regenerate after each implementation phase.*
--- a/docs/developer/INDEX.md
+++ b/docs/developer/INDEX.md
@@ -1,6 +1,6 @@
 # Developer Reference — UE5 Modular Game Framework
-**Version:** 1.3 | **Generated:** 2026-05-20 | **Files:** 16 (1 index + 2 overview + 1 migration + 1 starter + 10 category docs + 1 combined) | **Networking:** All docs include multiplayer sections
+**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
 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,8 @@ docs/developer/
 ├── INDEX.md                              ← THIS FILE
 ├── architecture-overview.md              ← Framework-wide architecture walkthrough
 ├── implementation-patterns.md            ← Common UE5 Blueprint patterns used
-├── project-setup-migration.md            ← Project setup & migration guide (NEW — Project Settings, plugins, init sequence)
+├── cpp-integration-guide.md              ← C++ per-system integration & setup (NEW — 12 systems)
-│
+├── project-setup-migration.md            ← Project setup & migration guide
 ├── 01-core-foundation.md                 ← Foundation systems (systems 01-07)
 ├── 00-starter-gameinstance.md            ← Starter GameInstance: GI_StarterGameInstance setup guide
 ├── 02-player-systems.md                  ← Player state & embodiment (systems 08-15)
 ├── 03-interaction-systems.md             ← Interaction & world manipulation (systems 16-23)
@@ -179,11 +178,12 @@ 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. **Implementing a system?** Read the Blueprint Spec in `docs/blueprints/` — every file has a Manual Implementation Guide with node-by-node logic.
+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.
-4. **Need to understand internals?** Read the corresponding Developer Reference doc in this directory.
+4. **Implementing a system?** Read the Blueprint Spec in `docs/blueprints/` — every file has a Manual Implementation Guide with node-by-node logic.
-5. **Debugging?** Each category doc includes a data flow section showing how data moves between systems.
+5. **Need to understand internals?** Read the corresponding Developer Reference doc in this directory.
-6. **Need UE5 Blueprint patterns?** See [`implementation-patterns.md`](implementation-patterns.md).
+6. **Debugging?** Each category doc includes a data flow section showing how data moves between systems.
-7. **Multiplayer networking?** See [`../architecture/multiplayer-networking.md`](../architecture/multiplayer-networking.md). Every doc has a Multiplayer Networking section.
+7. **Need UE5 Blueprint patterns?** See [`implementation-patterns.md`](implementation-patterns.md).
 8. **Multiplayer networking?** See [`../architecture/multiplayer-networking.md`](../architecture/multiplayer-networking.md). Every doc has a Multiplayer Networking section.
 ## Relationship to Spec Files
@@ -192,8 +192,8 @@ docs/developer/
 | **Purpose** | Define what to build with node-by-node logic (v2.0) | Explain how it works (understanding) |
 | **Audience** | Implementers building Blueprints manually | Anyone needing to understand internals |
 | **Content** | Enums, structs, variables, functions, **Manual Implementation Guide** | Data flow, state machines, design rationale |
-| **Format** | TEMPLATE.md v2.0 — includes Build Checklist | Per-category reference docs + project-setup-migration.md |
+| **Format** | TEMPLATE.md v2.0 — includes Build Checklist | Per-category reference docs + cpp-integration-guide + project-setup-migration |
 ---
-*Developer Reference Index v1.2 — Companion to the Blueprint Spec system. Update both together.*
+*Developer Reference Index v1.4 — Companion to the Blueprint Spec system. Update both together.*
--- a/docs/developer/cpp-integration-guide.md
+++ b/docs/developer/cpp-integration-guide.md
@@ -0,0 +1,626 @@
 # C++ Integration Guide — UE5 Modular Game Framework
 **Version:** 1.0 | **Generated:** 2026-05-20 | **Systems:** 12 C++ classes | **Pages:** Full per-system setup
 This guide covers every C++ class in `Source/Framework/`. For each system: what Blueprint child to create, what Project Settings to change, what assets to assign, and how other systems call into it.
 ---
 ## Setup Before You Start
 ### 1. Add Framework Module to Your Project
 In `Source/YourProject/YourProject.Build.cs`:
 ```csharp
 PublicDependencyModuleNames.Add("Framework");
 ```
 In `Source/YourProject.Target.cs`:
 ```csharp
 ExtraModuleNames.Add("Framework");
 ```
 ### 2. Verify GameplayTags Plugin
 `YourProject.uproject` must include:
 ```json
 "Plugins": [
    { "Name": "GameplayTags", "Enabled": true }
 ]
 ```
 ### 3. Create 11 Per-Category Data Tables
 Before any C++ code compiles usefully, create 11 Data Tables in `Content/Framework/Core/DataTables/` with Row Structure = `GameplayTagTableRow`. Register all 11 in `Project Settings → GameplayTags → Gameplay Tag Table List`.
 ---
 ## System 01 — DA_GameTagRegistry
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Core/DA_GameTagRegistry.h` |
 | **Source** | `Source/Framework/Private/Core/DA_GameTagRegistry.cpp` |
 | **Parent** | `UPrimaryDataAsset` |
 | **Blueprint Child** | **Not needed** — use directly as a Data Asset instance |
 ### Data Asset Setup
 1. Right-click in Content Browser → **Miscellaneous → Data Asset**
 2. Class: `DA_GameTagRegistry`
 3. Name: `DA_GameTagRegistry`
 4. Save to: `Content/Framework/Core/`
 5. Open the asset → assign the `TagDataTables` array with all 11 Data Tables
 ### Usage Pattern
 ```cpp
 // From any C++ code:
 UDA_GameTagRegistry* Registry = LoadObject<UDA_GameTagRegistry>(...);
 // Validate a tag:
 bool bValid = Registry->ValidateTag(SomeTag);
 // Get all tags:
 TArray<FGameplayTag> AllTags = Registry->GetAllRegisteredTags();
 // Create tag from string:
 FGameplayTag Tag = Registry->RequestTag(FName("Framework.Player.State.Alive"));
 ```
 ```blueprint
 // In Blueprint: Load Data Asset → cast to DA_GameTagRegistry → call functions
 // All functions are BlueprintCallable/Pure — identical API to BP-only version
 ```
 ### Key Win vs Blueprint
 The BP version required nested `ForEachLoop` over 11 Data Tables. C++ calls `UGameplayTagsManager::Get().RequestAllGameplayTags()` — one line.
 ---
 ## System 02 — FL_GameUtilities
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Core/FL_GameUtilities.h` |
 | **Source** | `Source/Framework/Private/Core/FL_GameUtilities.cpp` |
 | **Parent** | `UBlueprintFunctionLibrary` |
 | **Blueprint Child** | **None** — static function library, callable from anywhere |
 ### Usage Pattern
 ```cpp
 // Template subsystem access — single call replaces 3 BP nodes:
 USS_SaveManager* SaveMgr = UFL_GameUtilities::GetSubsystemSafe<USS_SaveManager>(this);
 // Math:
 float Remapped = UFL_GameUtilities::RemapFloat(0.5f, 0.0f, 1.0f, 0.0f, 100.0f); // → 50.0
 // Tag creation:
 FGameplayTag Tag = UFL_GameUtilities::MakeTagFromString(TEXT("Framework.Player.State.Alive"));
 // Debug (stripped from shipping):
 UFL_GameUtilities::DebugLog(TEXT("Hello"), true, 5.0f, FColor::Green);
 ```
 ```blueprint
 // All UFUNCTIONS appear in Blueprint context menu under "Framework|Utilities"
 // Template function not callable from BP — use "Get Game Framework" / "Get Subsystem by Class" nodes
 ```
 ### Key Win vs Blueprint
 Replaces "Get Game Instance → Get Subsystem(Class)" chains everywhere with one template call.
 ---
 ## System 03/04 — GI_GameFramework (I_InterfaceLibrary has no setup)
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Core/GI_GameFramework.h` |
 | **Source** | `Source/Framework/Private/Core/GI_GameFramework.cpp` |
 | **Parent** | `UGameInstance` |
 | **Blueprint Child to Create** | `BP_GameFramework` (or use `GI_StarterGameInstance` BP for early prototyping) |
 ### Project Settings
 1. **Project Settings → Maps & Modes → Game Instance Class** → Set to your BP child of `GI_GameFramework`
 2. Open the BP → Class Defaults → assign `TagRegistry` to the `DA_GameTagRegistry` Data Asset
 ### Blueprint Child Setup
 1. Create Blueprint Class → Parent: `GI_GameFramework`
 2. Name: `BP_GameFramework`
 3. In Class Defaults:
   - `TagRegistry` → assign `DA_GameTagRegistry`
   - `bValidateTagsOnInit` → `true`
   - `bLogTagsOnInit` → `false` (true for debugging)
 ### Usage Pattern
 ```cpp
 // Get the framework from anywhere:
 UGI_GameFramework* FW = Cast<UGI_GameFramework>(GetGameInstance());
 // Change game phase:
 FW->SetGamePhase(EGamePhase::InGame);
 // Session flags:
 FW->SetSessionFlag(Tag, true);
 bool bFlag = FW->GetSessionFlag(Tag);
 // Type-safe subsystem access:
 USS_SaveManager* Save = FW->GetService<USS_SaveManager>();
 // Check if framework ready:
 if (FW->IsFrameworkReady()) { ... }
 // Bind to dispatchers:
 FW->OnFrameworkReady.AddDynamic(this, &UMyClass::OnReady);
 FW->OnGamePhaseChanged.AddDynamic(this, &UMyClass::OnPhaseChange);
 ```
 ### Replace GI_StarterGameInstance
 When ready for the full GameInstance:
 1. Make `BP_GameFramework` your `Game Instance Class` in Project Settings
 2. Update any `Cast to GI_StarterGameInstance` → `Cast to GI_GameFramework`
 3. Both share the `OnFrameworkReady` dispatcher — bindings are compatible
 ---
 ## System 05 — GM_CoreGameMode
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Core/GM_CoreGameMode.h` |
 | **Source** | `Source/Framework/Private/Core/GM_CoreGameMode.cpp` |
 | **Parent** | `AGameModeBase` |
 | **Blueprint Child to Create** | `BP_CoreGameMode` |
 ### Blueprint Child Setup
 1. Create Blueprint Class → Parent: `GM_CoreGameMode`
 2. Name: `BP_CoreGameMode`
 3. In Class Defaults:
   - `GameState Class` → your `BP_CoreGameState`
   - `PlayerController Class` → your `BP_CorePlayerController`
   - `Default Pawn Class` → your player pawn
   - `HUD Class` → your `WBP_HUDController`
 ### Project Settings
 **Project Settings → Maps & Modes → Default GameMode** → `BP_CoreGameMode`
 ### Usage Pattern
 ```cpp
 AGM_CoreGameMode* GM = Cast<AGM_CoreGameMode>(GetWorld()->GetAuthGameMode());
 // Chapter transition:
 GM->TransitionToChapter(ChapterTag);
 // Death routing:
 GM->HandlePlayerDead(DeadController);
 // Ending trigger:
 GM->TriggerEnding(EndingTag);
 // Pause check:
 if (GM->bPauseAllowed) { /* show pause menu */ }
 ```
 ### Key Win vs Blueprint
 Server-authoritative `HasAuthority()` gates are compile-time checked. Chapter transitions are level-agnostic (tag-driven, no hardcoded map names).
 ---
 ## System 06 — GS_CoreGameState
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Core/GS_CoreGameState.h` |
 | **Source** | `Source/Framework/Private/Core/GS_CoreGameState.cpp` |
 | **Parent** | `AGameStateBase` |
 | **Blueprint Child to Create** | `BP_CoreGameState` |
 ### Usage Pattern
 ```cpp
 AGS_CoreGameState* GS = GetGameState<AGS_CoreGameState>();
 // Set chapter (server only — auto-replicates):
 GS->SetChapter(ChapterTag);
 // Add objective:
 GS->AddObjective(ObjectiveTag);
 // Bind to dispatchers:
 GS->OnChapterChanged.AddDynamic(this, &UMyHUD::OnChapterChanged);
 GS->OnObjectiveTagsChanged.AddDynamic(this, &UMyHUD::RefreshObjectives);
 GS->OnEncounterActiveStateChanged.AddDynamic(this, &UMyHUD::OnEncounterToggle);
 ```
 ### Multiplayer
 All 5 variables are fully replicated with `OnRep_` handlers. UI widgets bind to dispatchers — they fire for both local (server/listen-host) and remote (OnRep) clients with zero code changes.
 ---
 ## System 07 — DA_ItemData
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Inventory/DA_ItemData.h` |
 | **Source** | `Source/Framework/Private/Inventory/DA_ItemData.cpp` |
 | **Parent** | `UPrimaryDataAsset` |
 | **Blueprint Child** | **Not needed** — create Data Asset instances per item |
 ### Data Asset Instance Setup
 1. Right-click → **Miscellaneous → Data Asset**
 2. Class: `DA_ItemData`
 3. Name: `DA_Item_[Name]` (e.g. `DA_Item_MedKit`)
 4. Fill in properties — the editor hides irrelevant fields based on `ItemType`
 ### Editor UX Win
 The C++ `EditCondition` metadata means:
 - When `ItemType = Weapon`, EquipmentData shows (Damage, FireRate, MagazineSize...)
 - When `ItemType = Consumable`, ConsumableData shows (HealthRestore, StressReduce...)
 - When `bHasInspectMode = false`, InspectData is hidden entirely
 ### Usage Pattern
 ```cpp
 UDA_ItemData* Item = LoadObject<UDA_ItemData>(...);
 // Validate:
 FString Errors;
 if (!Item->ValidateItemData(Errors))
 {
    UE_LOG(..., Warning, TEXT("Item has errors: %s"), *Errors);
 }
 // Read properties:
 float Weight = Item->Weight;
 int32 StackLimit = Item->StackLimit;
 EItemType Type = Item->ItemType;
 ```
 ### Remaining BP to Create
 - `DA_Item_*` instances — one per game item (content, not code)
 - `WBP_InventoryMenu` (49) — uses `DA_ItemData` properties for display
 ---
 ## System 31 — BPC_InventorySystem
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Inventory/BPC_InventorySystem.h` |
 | **Source** | `Source/Framework/Private/Inventory/BPC_InventorySystem.cpp` |
 | **Parent** | `UActorComponent` |
 | **Blueprint Child to Create** | **None** — attach C++ component directly to player pawn |
 ### Setup
 1. Open your player pawn Blueprint
 2. Add Component → `BPC_InventorySystem`
 3. In component defaults:
   - `Grid Width` → 8
   - `Grid Height` → 5
   - `Max Weight` → 50.0
 ### Usage Pattern
 ```cpp
 UBPC_InventorySystem* Inv = GetOwner()->FindComponentByClass<UBPC_InventorySystem>();
 // Add item:
 int32 Added = Inv->AddItem(ItemData, 5);
 // Check if we can pick up:
 if (Inv->CanAddItem(ItemData, 1))
 {
    // Show pickup prompt
 }
 // Query:
 int32 Count = Inv->GetItemCount(ItemData);
 TArray<UDA_ItemData*> AllItems = Inv->GetAllItems();
 float RemainingWeight = Inv->GetRemainingWeight();
 // Organize:
 Inv->SortInventory();
 Inv->ConsolidateStacks();
 // Bind:
 Inv->OnInventoryChanged.AddDynamic(this, &UWBP_InventoryMenu::RefreshGrid);
 Inv->OnItemAdded.AddDynamic(this, &UWBP_InventoryMenu::OnItemAddedAnim);
 Inv->OnWeightChanged.AddDynamic(this, &UWBP_InventoryMenu::UpdateWeightBar);
 ```
 ### Key Win vs Blueprint
 `SortInventory` uses `Algo::Sort` with a C++ lambda — instantaneous. BP array sort requires manual iteration and comparison nodes. `AddItem` stacks automatically — no BP branching for each stack check.
 ---
 ## System 35 — SS_SaveManager
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Save/SS_SaveManager.h` |
 | **Source** | `Source/Framework/Private/Save/SS_SaveManager.cpp` |
 | **Parent** | `UGameInstanceSubsystem` |
 | **Blueprint Child** | **None** — auto-initialized by UE's subsystem system |
 ### No Manual Setup Required
 `UGameInstanceSubsystem` auto-creates when `GI_GameFramework` initializes. No BP child, no spawn, no BeginPlay needed.
 ### Usage Pattern
 ```cpp
 USS_SaveManager* Save = UFL_GameUtilities::GetSubsystemSafe<USS_SaveManager>(this);
 // Save:
 Save->SaveGame(0, TEXT("Chapter 3 — Laboratory"));
 // Load:
 Save->LoadGame(0);
 // Quick save/load:
 Save->QuickSave();
 Save->QuickLoad();
 // Checkpoint:
 Save->CreateCheckpoint(CheckpointTag);
 Save->LoadCheckpoint(SlotIndex);
 // Manifest:
 TArray<FSaveSlotInfo> Slots = Save->GetSlotManifest();
 // Backup:
 Save->BackupAllSaves(TEXT("Pre-Chapter4"));
 // Bind:
 Save->OnSaveComplete.AddDynamic(this, &UMyClass::OnSaved);
 Save->OnLoadComplete.AddDynamic(this, &UMyClass::OnLoaded);
 // Bind to manifest updates (when slots change):
 Save->OnSaveManifestUpdated.AddDynamic(this, &UWBP_SaveMenu::RefreshSlotList);
 ```
 ### Key Win vs Blueprint
 C++ uses `FArchive` for direct binary serialization. BP `Save Game`/`Load Game` nodes hide disk errors — C++ catches and reports them. `FMemoryWriter`/`FMemoryReader` is faster than BP serialization.
 ---
 ## System 72 — BPC_DamageReceptionSystem
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Weapons/BPC_DamageReceptionSystem.h` |
 | **Source** | `Source/Framework/Private/Weapons/BPC_DamageReceptionSystem.cpp` |
 | **Parent** | `UActorComponent` |
 | **Blueprint Child to Create** | **None** — attach to player and enemy pawns |
 ### Setup
 1. Open player pawn Blueprint (and enemy pawn Blueprint)
 2. Add Component → `BPC_DamageReceptionSystem`
 3. Optionally assign `EquipmentConfig` Data Asset for armor values
 ### Usage Pattern
 ```cpp
 UBPC_DamageReceptionSystem* Dmg = GetOwner()->FindComponentByClass<UBPC_DamageReceptionSystem>();
 // Apply damage (full pipeline: resistance → armor → shield → health → hit reaction):
 float ActualDamage = Dmg->ApplyDamage(
    50.0f,                    // Raw damage
    DamageCauser,             // Who dealt it
    DamageType,               // Framework.Combat.Damage.Physical
    HitLocation,              // Where on the body
    HitDirection              // Direction of the hit
 );
 // Preview damage (for UI):
 float EffectiveResist = Dmg->CalculateResistance(DamageType);
 // Bind:
 Dmg->OnDamageReceived.AddDynamic(this, &UMyClass::OnDamageReceived);
 Dmg->OnStaggered.AddDynamic(this, &UMyClass::OnStaggered);
 Dmg->OnKnockedDown.AddDynamic(this, &UMyClass::OnKnockedDown);
 Dmg->OnDamageResisted.AddDynamic(this, &UMyClass::OnDamageResisted);
 ```
 ### Key Win vs Blueprint
 The damage pipeline (resistance → multiplier → flat reduction → shield → health → hit reaction) is a single function call. In BP, this would be a 20+ node chain with multiple branches.
 ---
 ## System 128 — SS_EnhancedInputManager
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Input/SS_EnhancedInputManager.h` |
 | **Source** | `Source/Framework/Private/Input/SS_EnhancedInputManager.cpp` |
 | **Parent** | `UGameInstanceSubsystem` |
 | **Blueprint Child** | **None** — auto-initialized |
 ### No Manual Setup Required
 Auto-created by UE's subsystem system. No BP child needed.
 ### Usage Pattern
 ```cpp
 USS_EnhancedInputManager* Input = UFL_GameUtilities::GetSubsystemSafe<USS_EnhancedInputManager>(this);
 // Push context (e.g., when player hides):
 Input->PushContext(IMC_Hiding, EInputContextPriority::Hiding,
    FGameplayTag::RequestGameplayTag(FName("Framework.Input.Context.Hiding")));
 // Pop context (e.g., when player exits hiding):
 Input->PopContext(IMC_Hiding);
 // Switch to UI mode:
 Input->SetInputMode(true, true); // UI mode, show cursor
 // Switch back to game mode:
 Input->SetInputMode(false, false);
 // Rebind key:
 Input->RebindKey(IA_Reload, EKeys::R);
 // Query:
 bool bHidingActive = Input->IsContextActive(HidingTag);
 float MoveValue = Input->GetActionValue(IA_Move);
 bool bSprinting = Input->IsActionPressed(IA_Sprint);
 // Bind:
 Input->OnContextPushed.AddDynamic(this, &UMyClass::OnContextPushed);
 Input->OnContextPopped.AddDynamic(this, &UMyClass::OnContextPopped);
 Input->OnInputModeChanged.AddDynamic(this, &UMyClass::OnInputModeChanged);
 Input->OnKeyRebound.AddDynamic(this, &UMyClass::OnKeyRebound);
 ```
 ### Remaining BP to Create
 - `IA_*` Input Action assets (one per gameplay action)
 - `IMC_*` Input Mapping Context assets (groups of actions)
 - `DA_InputMappingProfile` (129) — per-platform binding Data Asset
 ---
 ## System 130 — BPC_StateManager
 ### C++ Class
 | | |
 |---|---|
 | **Header** | `Source/Framework/Public/Player/BPC_StateManager.h` |
 | **Source** | `Source/Framework/Private/Player/BPC_StateManager.cpp` |
 | **Parent** | `UActorComponent` |
 | **Blueprint Child to Create** | **None** — attach C++ component directly |
 ### Setup
 1. Open your player pawn Blueprint
 2. Add Component → `BPC_StateManager`
 3. In component defaults:
   - `Gating Table` → assign `DA_StateGatingTable` Data Asset
   - `Default Action State` → `Framework.State.Action.Idle`
   - `Heart Rate Smooth Speed` → 2.0
 ### Usage Pattern
 ```cpp
 UBPC_StateManager* State = GetOwner()->FindComponentByClass<UBPC_StateManager>();
 // THE central query — every gameplay system calls this:
 if (State->IsActionPermitted(ActionTag))
 {
    // Player can perform this action
 }
 // Request state change:
 EActionRequestResult Result = State->RequestStateChange(NewState, Requester);
 switch (Result)
 {
    case EActionRequestResult::Granted:        /* proceed */     break;
    case EActionRequestResult::Denied:         /* gated */       break;
    case EActionRequestResult::BlockedByForce: /* death/etc */   break;
    case EActionRequestResult::AlreadyActive:  /* no-op */       break;
 }
 // Force state (death, cutscene, void space):
 State->ForceStateChange(DeathTag, TEXT("Player died"));
 // Later, on respawn:
 State->RestorePreviousState();
 // Vital signs:
 float CurrentBPM = State->HeartRateBPM;
 EHeartRateTier Tier = State->HeartRateTier; // Resting/Elevated/Stressed/Panic/Critical
 // Bind:
 State->OnActionStateChanged.AddDynamic(this, &UMyClass::OnActionStateChanged);
 State->OnOverlayStateChanged.AddDynamic(this, &UMyClass::OnOverlayStateChanged);
 State->OnForceStackPushed.AddDynamic(this, &UMyClass::OnForceStackPushed);
 State->OnForceStackPopped.AddDynamic(this, &UMyClass::OnForceStackPopped);
 State->OnVitalSignChanged.AddDynamic(this, &UMyClass::OnVitalSignChanged);
 ```
 ### Key Win vs Blueprint
 `IsActionPermitted()` is on the **hot path** — called potentially per-frame by 10+ systems. In C++, it's a native `TArray`/`TMap` lookup. In BP, it would be interpretive graph traversal each call. Heart rate smoothing is `FMath::FInterpTo` in tick — one native call vs BP interpolation nodes.
 ### Remaining BP to Create
 - `DA_StateGatingTable` (131) — 37 gating rules Data Asset
 ---
 ## Quick Reference — C++ Class at a Glance
 | # | C++ Class | Parent | BP Child? | Project Settings Change? |
 |---|-----------|--------|-----------|--------------------------|
 | 01 | `UDA_GameTagRegistry` | `UPrimaryDataAsset` | No — use Data Asset instance | Register 11 Data Tables in GameplayTags |
 | 02 | `UFL_GameUtilities` | `UBlueprintFunctionLibrary` | No — static library | None |
 | 03 | 9 `UInterface`s | `UInterface` | No — implement on actors | None |
 | 04 | `UGI_GameFramework` | `UGameInstance` | **Yes** — `BP_GameFramework` | Set as Game Instance Class |
 | 05 | `AGM_CoreGameMode` | `AGameModeBase` | **Yes** — `BP_CoreGameMode` | Set as Default GameMode |
 | 06 | `AGS_CoreGameState` | `AGameStateBase` | **Yes** — `BP_CoreGameState` | Set in GameMode defaults |
 | 07 | `UDA_ItemData` | `UPrimaryDataAsset` | No — create per-item instances | None |
 | 31 | `UBPC_InventorySystem` | `UActorComponent` | No — add to pawn directly | None |
 | 35 | `USS_SaveManager` | `UGameInstanceSubsystem` | No — auto-created | None |
 | 72 | `UBPC_DamageReceptionSystem` | `UActorComponent` | No — add to pawn/enemy | None |
 | 128 | `USS_EnhancedInputManager` | `UGameInstanceSubsystem` | No — auto-created | None |
 | 130 | `UBPC_StateManager` | `UActorComponent` | No — add to pawn directly | None |
 ### What "No BP Child" Means
 Systems marked **"No — add to pawn directly"** mean you place the raw C++ component on your Blueprint pawn. The C++ class exposes all configuration via `EditAnywhere` properties — designers tweak those in the Details panel instead of a Blueprint child.
 Systems marked **"No — auto-created"** are `UGameInstanceSubsystem`s. UE creates them automatically when the GameInstance initializes. No spawning, no placement, no BeginPlay required.
 ---
 ## Build Order (Dependency Chain)
 ```
 1. DA_GameTagRegistry          ← No dependencies (can build first)
 2. I_InterfaceLibrary           ← No dependencies
 3. FL_GameUtilities             ← Needs GI_GameFramework (forward declare ok)
 4. GI_GameFramework             ← Needs DA_GameTagRegistry
 5. GM_CoreGameMode              ← Needs GI_GameFramework
 6. GS_CoreGameState             ← Needs GI_GameFramework
 7. DA_ItemData                  ← No C++ dependencies
 8. BPC_InventorySystem          ← Needs DA_ItemData
 9. SS_SaveManager               ← Needs GI_GameFramework
 10. BPC_DamageReceptionSystem   ← Needs DA_ItemData (EquipmentConfig)
 11. SS_EnhancedInputManager     ← No C++ framework deps (EnhancedInput plugin only)
 12. BPC_StateManager            ← Needs DA_StateGatingTable (stub)
 ```
 ---
 ## Blueprint Assets Still Required (Not Converted to C++)
 These Blueprint specs remain Blueprint-only. They have full spec files in `docs/blueprints/` with Manual Implementation Guides.
 ### GameInstance Subsystems (auto-created, need BP children)
 | # | System | BP to Create | C++ Status |
 |---|--------|-------------|------------|
 | 44 | `SS_UIManager` | `BP_UIManager` | C++ available (not in this batch — low priority) |
 | 103 | `SS_AchievementSystem` | `BP_AchievementSystem` | C++ available (not in this batch) |
 | 105 | `SS_SettingsSystem` | `BP_SettingsSystem` | C++ available (not in this batch) |
 | 132 | `SS_AudioManager` | `BP_AudioManager` | C++ available (not in this batch) |
 ### Actor Components (attach to pawn)
 All 80 `BPC_*` specs except the 4 converted above remain Blueprint-only. Create BP children, attach to pawn.
 ### Widgets (all 14 remain Blueprint — UMG is designed for BP)
 | # | System |
 |---|--------|
 | 45-57 | All `WBP_*` widgets (HUD, menus, notifications, etc.) |
 | 112-114 | Credits, Debug, Splash screens |
 ### Data Assets (create instances, not children)
 | # | System |
 |---|--------|
 | 115-127, 129, 131, 134-135 | All `DA_*` Data Asset definitions — create instances per content item |
 ### Actors (create BP children)
 | # | System |
 |---|--------|
 | 19, 20, 25, 37, 67, 69, 80, 81, 133 | All `BP_*` actors |
 ### Interfaces
 | 17 | `I_HidingSpot` — remains BP interface (simple, no C++ advantage) |
 | 36 | `I_Persistable` — already in C++ `I_InterfaceLibrary.h` |
 ---
 *C++ Integration Guide v1.0 — Companion to Source/Framework/ source files.*