admin/UE5-Modular-Game-Framework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: Update C++ integration guide and blueprint specifications for various systems, adding detailed setup instructions and clarifying implementation statuses

Browse Source
This commit is contained in:
Lefteris Notas
2026-05-21 21:29:03 +03:00
parent 0852386168
commit bcbfcdf167
21 changed files with 133 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
docs/blueprints/01-core/01_DA_GameTagRegistry.md
View File

@@ -5,10 +5,12 @@
> **Category:** 01-Core / Foundation
> **Build Phase:** Phase 0 — Item 1
> **Dependencies:** None (this is the first system)
---
## 1. Purpose
>
> ---
>
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Core/DA_GameTagRegistry.h` provides all tag query, validation, and export functions. The Blueprint spec below documents the API and Data Table configuration. **Do NOT create a Blueprint child** — create a **Data Asset instance** (Right-click → Miscellaneous → Data Asset → pick `DA_GameTagRegistry`). Assign the 11 `TagDataTables`. All functions are `BlueprintCallable` — call them from any BP. See `docs/developer/cpp-integration-guide.md` for exact setup steps.
>
> ---## 1. Purpose
Centralises every `GameplayTag` namespace used across the framework in a single asset. All other systems reference tags from this registry — never raw strings, never `FName` comparisons, never hardcoded booleans for state.

4
docs/blueprints/01-core/02_FL_GameUtilities.md
View File

@@ -1,5 +1,9 @@
# FL_GameUtilities — Blueprint Function Library
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Core/FL_GameUtilities.h` provides all utility functions (subsystem access, math, tags, text, screen, debug). All functions are `BlueprintCallable` — they appear under `Framework|Utilities` in every BP right-click menu. **Nothing to build.** The spec below documents each function's API for reference. The old "Blueprint-Only Alternative" section is kept for context but is no longer needed — the C++ class is the canonical implementation. See `docs/developer/cpp-integration-guide.md` for usage patterns.
>
> ---
## Asset Details
| Property | Value |

4
docs/blueprints/01-core/03_I_InterfaceLibrary.md
View File

@@ -1,5 +1,9 @@
# I_InterfaceLibrary — Interface Collection
> **⚡ C++ Status: Full Implementation** — All 9 interfaces (`I_Interactable`, `I_Damageable`, `I_Persistable`, `I_Lockable`, `I_Holdable`, `I_UsableItem`, `I_Toggleable`, `I_Adjustable`, `I_Inspectable`) are defined in C++ at `Source/PG_Framework/Public/Core/I_InterfaceLibrary.h` as `BlueprintNativeEvent`. **Do NOT create Blueprint Interface assets.** On any BP actor: Class Settings → Interfaces → Add → type the interface name (e.g., `UInteractable`). Compile, and the interface events appear in your Event Graph. The spec below documents each interface's functions and purpose for reference. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Overview
This document defines all **9 Blueprint Interfaces** that form the backbone of cross-system communication in the framework. Interfaces are the **preferred communication method** over direct references — they decouple the caller from the callee's concrete class. Any Actor or Component can implement any of these interfaces, and any system can query for them and call them without knowing the underlying type.

4
docs/blueprints/01-core/04_GI_GameFramework.md
View File

@@ -1,5 +1,9 @@
# 04 — Game Instance Kernel (`GI_GameFramework`)
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Core/GI_GameFramework.h` provides the complete application kernel: game phase state machine, session flags, save slot management, service resolution, platform initialization, and all event dispatchers. **Create a BP child** (Blueprint Class → All Classes → `GI_GameFramework`) for configuration only — set `TagRegistry` in Class Defaults. Do NOT rebuild the state machine or service registry in BP. See `docs/developer/cpp-integration-guide.md` for exact setup steps.
>
> ---
## Purpose
The single persistent object that lives for the entire application session. It owns global subsystems, manages save slot ownership, and provides the canonical entry point for service resolution.

4
docs/blueprints/01-core/05_GM_CoreGameMode.md
View File

@@ -1,6 +1,8 @@
# GM_CoreGameMode — Core GameMode
---
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Core/GM_CoreGameMode.h` provides chapter transitions, death handling, ending triggers, and pause control. **Create a BP child** (Blueprint Class → All Classes → `GM_CoreGameMode`). In Class Defaults → **"Classes"** section (inherited from `AGameModeBase`): set `PlayerControllerClass`, `PlayerStateClass`, `GameStateClass`, and `DefaultPawnClass`. Do NOT redeclare these variables — they're inherited. See `docs/developer/cpp-integration-guide.md` for exact setup steps.
>
> ---
## Asset Details

4
docs/blueprints/01-core/06_GS_CoreGameState.md
View File

@@ -1,5 +1,9 @@
# 06 — Core GameState (`GS_CoreGameState`)
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Core/GS_CoreGameState.h` provides 5 replicated state variables (ElapsedPlayTime, ActiveChapterTag, ActiveNarrativePhase, bEncounterActive, ActiveObjectiveTags) with `OnRep_` handlers and dispatchers. **Create a BP child** (Blueprint Class → All Classes → `GS_CoreGameState`). No logic to add — all replication works out of the box. Set in `BP_CoreGameMode` → Class Defaults → Classes → `Game State Class`. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Purpose
The single replicated game state object visible to all players (and potential future co-op clients). Tracks session-level progression data such as elapsed play time, active chapter, narrative phase, encounter activity, and active objectives.

4
docs/blueprints/02-player/08_BPC_HealthSystem.md
View File

@@ -1,5 +1,9 @@
# 08 — Health System (`BPC_HealthSystem`)
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Player/BPC_HealthSystem.h` provides the UCLASS shell, `MaxHealth`/`CurrentHealth` variables, `OnHealthChanged` and `OnDeath` event dispatchers. **The C++ stub has NO gameplay logic** — it exists so other C++ classes (`BPC_StateManager`, `BPC_DamageReceptionSystem`) can forward-reference it. **Create a BP child** and build ALL logic from this spec: `TakeDamage()`, `Heal()`, `OnDeath()` transition, damage resistance modifiers, health regen tick, `I_Damageable` interface. See `docs/developer/cpp-integration-guide.md` for setup steps.
>
> ---
## Purpose
Manages the player's health pool, damage application with type-based resistance, health regeneration, death state, and critical-health events. Serves as the central survivability component on the player character.

4
docs/blueprints/02-player/09_BPC_StaminaSystem.md
View File

@@ -1,5 +1,9 @@
# 09 — Stamina System (`BPC_StaminaSystem`)
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Player/BPC_StaminaSystem.h` provides the UCLASS shell, `MaxStamina`/`CurrentStamina` variables, and `OnExhaustionStateChanged` dispatcher. **The C++ stub has NO gameplay logic.** **Create a BP child** and build ALL logic: sprint drain, action costs, exhaustion state machine, regen delay + rate, `CanAffordAction(Cost)` query. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Purpose
Manages the player's stamina pool — drain during sprinting, jumping, and special actions; regeneration during idle/walking. Prevents action spamming by enforcing minimum stamina thresholds. Drives exhaustion VFX and audio cues.

4
docs/blueprints/02-player/10_BPC_StressSystem.md
View File

@@ -1,5 +1,9 @@
# 10 — Stress / Sanity System (`BPC_StressSystem`)
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Player/BPC_StressSystem.h` provides the UCLASS shell, `EStressTier` enum (Calm→Catatonic), `StressTier` variable, and `OnStressTierChanged` dispatcher. **The C++ stub has NO gameplay logic.** **Create a BP child** and build ALL logic: stress accumulation sources, decay during safety, tier transitions, hallucination thresholds. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Purpose
Tracks the player's psychological state via a stress meter that accumulates from environmental horror, enemy proximity, health deficits, and narrative events. Drives visual distortion, audio hallucinations, gameplay penalties, and narrative branching based on sanity thresholds.

4
docs/blueprints/02-player/11_BPC_MovementStateSystem.md
View File

@@ -1,5 +1,9 @@
# 11 — Movement State System (`BPC_MovementStateSystem`)
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Player/BPC_MovementStateSystem.h` provides the UCLASS shell, `CurrentMovementMode` GameplayTag variable, and `OnMovementModeChanged` dispatcher. **The C++ stub has NO gameplay logic.** **Create a BP child** and build ALL logic: CMC reads, posture detection (standing/crouching/prone), sprint state, footstep events, GASP ABP variable bridge. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Purpose
Tracks the player's current movement mode and posture state. Acts as a central query point for other systems (animations, stamina, audio, camera) to react to how the player is moving. Does not control movement input — only reports and reacts to state changes.

8
docs/blueprints/04-inventory/31_BPC_InventorySystem.md
View File

@@ -3,11 +3,11 @@
**Parent Class:** `ActorComponent`
**Category:** Inventory
**Target UE Version:** 5.5–5.7
**Build Phase:** 3 — Inventory
**Build Phase:** 4 — Inventory
---
## 1. Overview
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Inventory/BPC_InventorySystem.h` provides the complete inventory grid: add/remove/query/sort/consolidate/weight tracking with native-speed TArray operations. **Attach directly to player pawn** (Add Component → `BPC_InventorySystem`). Set `GridWidth`, `GridHeight`, `MaxWeight` in Details panel. Do NOT create a BP child — the C++ component has all logic. See `docs/developer/cpp-integration-guide.md` for usage patterns.
>
> ---## 1. Overview
`BPC_InventorySystem` is the central inventory authority on the player. It manages an array of item instances (stackable, tagged, data-driven), handles add/remove/use/transfer operations, enforces capacity limits, and communicates state changes via Event Dispatchers. All other inventory subsystems (weight, quick slots, UI, equipment) read from this component as their single source of truth.

4
docs/blueprints/05-saveload/35_SS_SaveManager.md
View File

@@ -2,6 +2,10 @@
**File:** [`Content/Framework/Save/SS_SaveManager`](Content/Framework/Save/SS_SaveManager.uasset)
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Save/SS_SaveManager.h` provides the complete save/load subsystem: slot manifest, save/load/delete, quick-save/load, checkpoint management, backup, FArchive binary serialization. **Auto-created** by UE's subsystem system when `GI_GameFramework` initializes — no BP child, no spawning needed. Access from any BP: `Get Game Instance → Get Subsystem(SS_SaveManager)`. See `docs/developer/cpp-integration-guide.md`.
>
> ---
**Purpose:** The single authority for all serialisation and deserialisation of game state to disk. Supports multiple save slots, checkpoint saves, hard saves, auto-saves, and world object persistence.
**Depends On:** [`GI_GameFramework`](../01-core/04_GI_GameFramework.md), [`I_Persistable`](30_I_Persistable.md)

4
docs/blueprints/05-saveload/36_I_Persistable.md
View File

@@ -2,6 +2,10 @@
**File:** [`Content/Framework/Save/I_Persistable`](Content/Framework/Save/I_Persistable.uasset)
> **⚡ C++ Status: Full Implementation** — Defined in `Source/PG_Framework/Public/Core/I_InterfaceLibrary.h` as `BlueprintNativeEvent`. **Do NOT create a Blueprint Interface asset.** On any actor that needs save/load: Class Settings → Interfaces → Add → `UPersistable`. Override `On Save`, `On Load`, `Get Save Tag`, `Needs Save`. See `docs/developer/cpp-integration-guide.md`.
>
> ---
**Purpose:** Interface for any Actor or Component in the world that needs to save or restore per-instance state. Implemented by doors, containers, lootable objects, hidden collectibles, puzzle elements, destructibles, and any other persistent world actor.
**Depends On:** None

4
docs/blueprints/08-weapons/72_BPC_DamageReceptionSystem.md
View File

@@ -1,5 +1,9 @@
# BPC_DamageReceptionSystem — Damage Reception System
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Weapons/BPC_DamageReceptionSystem.h` provides the complete damage pipeline: raw damage → resistance → armor → shield → health → hit reaction. **Attach directly to player/enemy pawns** (Add Component → `BPC_DamageReceptionSystem`). Call `ApplyDamage(RawDamage, Causer, DamageType, HitLocation, HitDirection)`. Set `StaggerThreshold`/`KnockdownThreshold` in Details panel. Do NOT create a BP child. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Blueprint Spec — UE 5.5–5.7
---

4
docs/blueprints/08-weapons/75_BPC_HitReactionSystem.md
View File

@@ -1,5 +1,9 @@
# BPC_HitReactionSystem — Hit Reaction System
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Weapons/BPC_HitReactionSystem.h` provides the UCLASS shell, `PlayHitReaction()` stub, `FlinchThreshold`, and `RagdollThreshold`. **The C++ stub has NO gameplay logic.** **Create a BP child** and build ALL logic: hit reaction animation selection, stagger/knockdown/ragdoll trigger, directional response, camera trauma. Attach to player/enemy pawns. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Blueprint Spec — UE 5.5–5.7
---

4
docs/blueprints/08-weapons/79_BPC_ShieldDefenseSystem.md
View File

@@ -1,5 +1,9 @@
# BPC_ShieldDefenseSystem — Actor Component
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Weapons/BPC_ShieldDefenseSystem.h` provides the UCLASS shell, `ShieldHealth`, `MaxShieldHealth`, `BlockAngle`, `bShieldBroken`. **The C++ stub has NO gameplay logic.** **Create a BP child** and build ALL logic: shield raise/lower, block detection, damage reduction while blocking, break effect, stamina drain. Attach to player pawn. See `docs/developer/cpp-integration-guide.md`.
>
> ---
**File:** [`Content/Framework/Weapons/BPC_ShieldDefenseSystem`](Content/Framework/Weapons/BPC_ShieldDefenseSystem.uasset)
**Parent Class:** `UActorComponent`
**Dependencies:** [`BPC_DamageReceptionSystem`](BPC_DamageReceptionSystem.md), [`BPC_StaminaSystem`](../02-player/09_BPC_StaminaSystem.md)

4
docs/blueprints/14-data-assets/120_DA_EquipmentConfig.md
View File

@@ -1,5 +1,9 @@
# DA_EquipmentConfig — Data Asset
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/Inventory/DA_EquipmentConfig.h` provides `FDamageTypeResistance` struct (DamageType GameplayTag + Resistance float), `Durability`, `Weight`, and `GetResistance()` query. **Create Data Asset instances** (Right-click → Miscellaneous → Data Asset → `DA_EquipmentConfig`), one per equipment piece. Fill in damage resistances per type. See `docs/developer/cpp-integration-guide.md`.
>
> ---
**Parent Class:** `UDataAsset`
**Dependencies:** [`BPC_EquipmentSlotSystem`](../04-inventory/BPC_EquipmentSlotSystem.md)
**Purpose:** Defines equipment slot configurations — which item categories map to which slots, socket names, and auto-equip rules.

4
docs/blueprints/15-input/128_SS_EnhancedInputManager.md
View File

@@ -1,5 +1,9 @@
# 128 — Enhanced Input Manager (`SS_EnhancedInputManager`)
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Input/SS_EnhancedInputManager.h` provides the complete context stack management: Push/Pop context with priority ordering, input mode coordination, key rebinding, and action value queries. **Auto-created** by UE's subsystem system — no BP child needed. Access from any BP: `Get Game Instance → Get Subsystem(SS_EnhancedInputManager)`. You still need to create 22 IA_* + 5 IMC_* assets in the editor. See `docs/developer/cpp-integration-guide.md` for usage patterns.
>
> ---
## Purpose
Centralized Game Instance Subsystem that manages all UE5 Enhanced Input operations: Input Mapping Context push/pop with priority stack, platform-specific binding profiles, key rebinding, input mode coordination with [`SS_UIManager`](docs/blueprints/06-ui/44_SS_UIManager.md), and read-only input state queries for gameplay systems.

4
docs/blueprints/16-state/130_BPC_StateManager.md
View File

@@ -1,5 +1,9 @@
# 130 — Central State Authority (`BPC_StateManager`)
> **⚡ C++ Status: Full Implementation** — `Source/PG_Framework/Public/Player/BPC_StateManager.h` provides the complete state authority: `IsActionPermitted()` hot-path query, `RequestStateChange()`, `ForceStateChange()`/`RestorePreviousState()` force stack, heart rate BPM smoothing with tier detection, gating rule evaluation. **Attach directly to player pawn** (component slot 0). Set `GatingTable` → `DA_StateGatingTable` in Details panel. Do NOT create a BP child. See `docs/developer/cpp-integration-guide.md` for usage patterns.
>
> ---
## Purpose
Single source of truth for "what can the player do right now?" Every system queries `IsActionPermitted(Tag)` instead of checking other systems' states directly. Manages exclusive action states, upper-body overlay states, action action gating, vital signs (heart rate), and the force-stack pattern for nested overrides (death, cutscenes, void space). Communicates with GASP exclusively through overlay state variables — never touches motion matching internals.

4
docs/blueprints/16-state/131_DA_StateGatingTable.md
View File

@@ -1,5 +1,9 @@
# 131 — State Gating Table (`DA_StateGatingTable`)
> **⚡ C++ Status: Stub** — `Source/PG_Framework/Public/State/DA_StateGatingTable.h` provides the `FStateGatingRule` struct (ActionTag, BlockedByState, bIsBlocked) and `IsActionGated()` query. **Create a Data Asset instance** (Right-click → Miscellaneous → Data Asset → `DA_StateGatingTable`). Populate `GatingRules` with 37 rules. The C++ `BPC_StateManager` reads this asset — no BP logic to build. Designers modify gating rules in this Data Asset without touching code. See `docs/developer/cpp-integration-guide.md`.
>
> ---
## Purpose
Data Asset that holds all state gating rules for the framework. Loaded by `BPC_StateManager` on BeginPlay to populate its `GatingRules` array. Designers modify gating rules entirely through this Data Asset — no blueprint changes required to add, remove, or tweak which states block which actions.

53
docs/developer/cpp-integration-guide.md
View File

@@ -1,11 +1,62 @@
# C++ Integration Guide — UE5 Modular Game Framework
**Version:** 1.0 | **Generated:** 2026-05-20 | **Systems:** 12 C++ classes | **Pages:** Full per-system setup
**Version:** 1.1 | **Generated:** 2026-05-21 | **Systems:** 22 C++ classes (12 full + 10 stubs) | **Pages:** Full per-system setup
This guide covers every C++ class in `Source/PG_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.
---
## Quick Start — What to Do With Each C++ Class
If you just want to know what action to take for each C++ class, start here. Detailed setup follows in the per-system sections below.
| # | C++ Class | Status | **Exact Action to Take** |
|---|-----------|--------|--------------------------|
| 01 | `UDA_GameTagRegistry` | ✅ Full | Create a **Data Asset instance**: Right-click → Miscellaneous → Data Asset → pick `DA_GameTagRegistry`. Assign 11 Data Tables to `TagDataTables` array. |
| 02 | `UFL_GameUtilities` | ✅ Full | **Nothing.** Static library — functions appear under `Framework\|Utilities` in every BP right-click menu. |
| 03 | 9 `UInterface`s | ✅ Full | **Nothing to create.** On any BP actor: Class Settings → Interfaces → Add → type `UInteractable`, `UDamageable`, `ULockable`, etc. Events auto-appear. |
| 04 | `UGI_GameFramework` | ✅ Full | Create **BP child**: Blueprint Class → All Classes → `GI_GameFramework`. Set `TagRegistry` in Class Defaults. Assign in Project Settings as Game Instance Class. |
| 05 | `AGM_CoreGameMode` | ✅ Full | Create **BP child**: Blueprint Class → All Classes → `GM_CoreGameMode`. In Class Defaults → **"Classes"** section (inherited from AGameModeBase) → set all 4 class references. Assign in Project Settings as Default GameMode. |
| 06 | `AGS_CoreGameState` | ✅ Full | Create **BP child**: Blueprint Class → All Classes → `GS_CoreGameState`. No config needed — replicated state works automatically. |
| 07 | `UDA_ItemData` | ✅ Full | Create **Data Asset instances** (one per item): Right-click → Miscellaneous → Data Asset → `DA_ItemData`. Fill ItemTag, DisplayName, Icon, WorldMesh, Weight, ItemType, etc. See [game examples](../game/). |
| 08 | `UBPC_HealthSystem` | 🟡 Stub | Create **BP child** → attach to player pawn. C++ provides `MaxHealth`, `CurrentHealth`, `OnHealthChanged`, `OnDeath` dispatchers. Add `TakeDamage()`, `Heal()`, regen logic in BP. |
| 09 | `UBPC_StaminaSystem` | 🟡 Stub | Create **BP child** → attach to player pawn. C++ provides `MaxStamina`, `CurrentStamina`, `OnExhaustionStateChanged`. Add drain/regen/exhaustion logic in BP. |
| 10 | `UBPC_StressSystem` | 🟡 Stub | Create **BP child** → attach to player pawn. C++ provides `EStressTier` enum + `OnStressTierChanged` dispatcher. Add accumulation/decay/tier-transition logic in BP. |
| 11 | `UBPC_MovementStateSystem` | 🟡 Stub | Create **BP child** → attach to player pawn. C++ provides `CurrentMovementMode` GameplayTag + `OnMovementModeChanged` dispatcher. Add CMC reads, GASP bridge, posture detection in BP. |
| — | `APC_CoreController` | 🟡 Stub | Create **BP child** → set in `GM_CoreGameMode` Class Defaults. Add `BeginPlay`: cast to `GI_GameFramework` → `GetSubsystem<SS_EnhancedInputManager>` → `PushContext(IMC_Default)`. |
| — | `APS_CorePlayerState` | 🟡 Stub | Create **BP child** → set in `GM_CoreGameMode` Class Defaults. Add replicated variables (inventory, equipped items, narrative flags) with `OnRep_` handlers. |
| 31 | `UBPC_InventorySystem` | ✅ Full | **Attach directly to player pawn** — no BP child needed. Add Component → `BPC_InventorySystem`. Set `GridWidth=8`, `GridHeight=5`, `MaxWeight=50` in Details panel. |
| 35 | `USS_SaveManager` | ✅ Full | **Auto-created** by UE's subsystem system. Access from any BP: `FL_GameUtilities::GetSubsystemSafe<USS_SaveManager>()` or `Get Game Instance → Get Subsystem(SS_SaveManager)`. |
| 72 | `UBPC_DamageReceptionSystem` | ✅ Full | **Attach directly to player/enemy pawns** — no BP child needed. Add Component → `BPC_DamageReceptionSystem`. Call `ApplyDamage(RawDamage, Causer, DamageType, HitLocation, HitDirection)`. |
| 75 | `UBPC_HitReactionSystem` | 🟡 Stub | Create **BP child** → attach to player/enemy pawns. C++ provides `PlayHitReaction()` stub + `FlinchThreshold` + `RagdollThreshold`. Add animation selection/trigger logic in BP. |
| 79 | `UBPC_ShieldDefenseSystem` | 🟡 Stub | Create **BP child** → attach to player pawn. C++ provides `ShieldHealth`, `MaxShieldHealth`, `BlockAngle`, `bShieldBroken`. Add block/raise/lower/break logic in BP. |
| 120 | `UDA_EquipmentConfig` | 🟡 Stub | Create **Data Asset instances** (one per equipment piece). C++ provides `FDamageTypeResistance` struct + `GetResistance()` query. |
| 128 | `USS_EnhancedInputManager` | ✅ Full | **Auto-created** by UE. Access via `GetSubsystem<USS_EnhancedInputManager>()`. Call `PushContext()` / `PopContext()` / `SetInputMode()`. Create 22 IA_* + 5 IMC_* assets in editor. |
| 130 | `UBPC_StateManager` | ✅ Full | **Attach directly to player pawn** (component slot 0). Assign `GatingTable` → `DA_StateGatingTable`. Every system calls `IsActionPermitted(Tag)`. |
| 131 | `UDA_StateGatingTable` | 🟡 Stub | Create **Data Asset instance** — populate `GatingRules` with 37 rules (ActionTag, BlockedByState, bIsBlocked). C++ provides `FStateGatingRule` struct + `IsActionGated()`. |
### What "Full" vs "Stub" vs "Auto-Created" Means
| Term | Meaning | Example |
|------|---------|---------|
| **Full C++** | Complete gameplay logic compiled natively. The asset you create (BP child or Data Asset instance) is only for configuration — no logic to add. | `BPC_InventorySystem` — attach, set grid size, call `AddItem()` |
| **C++ Stub** | C++ has the UCLASS shell, basic variables, and event dispatchers so the module can compile (other classes forward-reference it). You must add all gameplay logic in the BP child. | `BPC_HealthSystem` — C++ gives you `MaxHealth` + `OnDeath`. You add `TakeDamage()`, regen, death sequence. |
| **Auto-Created** | `UGameInstanceSubsystem`. UE creates it automatically when GameInstance initializes. No spawning, no placement, no BP child needed. Access via `GetSubsystem<T>()`. | `SS_SaveManager`, `SS_EnhancedInputManager` |
| **Data Asset Instance** | Not a Blueprint at all. Right-click → Miscellaneous → Data Asset → pick the C++ class. Fill in properties. Systems reference it by pointer. | `DA_Item_MedKit`, `DA_StateGatingTable` |
### Interfaces: You Don't Build Them, You Implement Them
All 9 interfaces (`I_Interactable`, `I_Damageable`, `I_Persistable`, `I_Lockable`, `I_Holdable`, `I_UsableItem`, `I_Toggleable`, `I_Adjustable`, `I_Inspectable`) are in C++. You do **not** create Blueprint interface assets.
To use them on any BP actor:
1. **Class Settings → Interfaces → Add** → type `UInteractable` (or `UDamageable`, etc.)
2. **Compile** — the interface events appear in your Event Graph
3. Override `Interact`, `Can Interact`, `Get Interaction Prompt`, etc.
Other systems call these interfaces through C++ `BlueprintNativeEvent` functions — the framework never checks "Is this a BP_ItemPickup?" It checks "Does this implement I_Interactable?"
---
## Setup Before You Start
### 1. Add Framework Module to Your Project