admin/UE5-Modular-Game-Framework
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9ee0a656306220963576227e769e490b32369570
UE5-Modular-Game-Framework/docs/developer/cpp-integration-guide.md

28 KiB
Raw Blame History

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:

PublicDependencyModuleNames.Add("Framework");

In Source/YourProject.Target.cs:

ExtraModuleNames.Add("Framework");

2. Verify GameplayTags Plugin

YourProject.uproject must include:

"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

// 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"));

// 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

// 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);

// 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

// 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

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

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

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

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

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

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

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

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

  • Data Asset instance: DA_StateGatingTable — populate with 37 gating rules (C++ stub class is ready, create the asset instance)

Stub Classes (UHT Resolution — 10 Systems)

These 10 classes are forward-declared in existing C++ headers as TObjectPtr<> or TSubclassOf<> UPROPERTY members. They must exist as C++ UCLASS() definitions for UHT to process the Framework module. The Blueprint child provides the actual runtime implementation.

System 08 — BPC_HealthSystem
Header Source/Framework/Public/Player/BPC_HealthSystem.h
Source Source/Framework/Private/Player/BPC_HealthSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_HealthSystem — attach to player pawn, implement health logic

Provides CurrentHealth, MaxHealth, OnHealthChanged dispatcher, OnDeath dispatcher. Referenced by BPC_StateManager (130) and BPC_DamageReceptionSystem (72).

System 09 — BPC_StaminaSystem
Header Source/Framework/Public/Player/BPC_StaminaSystem.h
Source Source/Framework/Private/Player/BPC_StaminaSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_StaminaSystem — attach to player pawn

Provides CurrentStamina, MaxStamina, OnExhaustionStateChanged dispatcher. Referenced by BPC_StateManager (130).

System 10 — BPC_StressSystem
Header Source/Framework/Public/Player/BPC_StressSystem.h
Source Source/Framework/Private/Player/BPC_StressSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_StressSystem — attach to player pawn

Provides EStressTier enum (Calm → Catatonic), StressTier property, OnStressTierChanged dispatcher. Referenced by BPC_StateManager (130).

System 11 — BPC_MovementStateSystem
Header Source/Framework/Public/Player/BPC_MovementStateSystem.h
Source Source/Framework/Private/Player/BPC_MovementStateSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_MovementStateSystem — attach to player pawn

Provides CurrentMovementMode (FGameplayTag), OnMovementModeChanged dispatcher. Referenced by BPC_StateManager (130).

PC_CoreController / PS_CorePlayerState

APC_CoreController APS_CorePlayerState
Header Public/Player/PC_CoreController.h Public/Player/PS_CorePlayerState.h
Source Private/Player/PC_CoreController.cpp Private/Player/PS_CorePlayerState.cpp
Parent APlayerController APlayerState
Blueprint Child to Create PC_CoreController PS_CorePlayerState

Minimal stubs. Referenced as TSubclassOf<> in GM_CoreGameMode (05). Set your BP children as the default classes in BP_CoreGameMode Class Defaults.

System 75 — BPC_HitReactionSystem
Header Source/Framework/Public/Weapons/BPC_HitReactionSystem.h
Source Source/Framework/Private/Weapons/BPC_HitReactionSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_HitReactionSystem — attach to player and enemy pawns

Provides PlayHitReaction() stub, FlinchThreshold, RagdollThreshold. Referenced by BPC_DamageReceptionSystem (72).

System 79 — BPC_ShieldDefenseSystem
Header Source/Framework/Public/Weapons/BPC_ShieldDefenseSystem.h
Source Source/Framework/Private/Weapons/BPC_ShieldDefenseSystem.cpp
Parent UActorComponent
Blueprint Child to Create BPC_ShieldDefenseSystem — attach to player pawn

Provides ShieldHealth, MaxShieldHealth, BlockAngle, bShieldBroken. Referenced by BPC_DamageReceptionSystem (72).

System 120 — DA_EquipmentConfig
Header Source/Framework/Public/Inventory/DA_EquipmentConfig.h
Source Source/Framework/Private/Inventory/DA_EquipmentConfig.cpp
Parent UPrimaryDataAsset
Blueprint Child Not needed — create Data Asset instances per equipment item

Provides FDamageTypeResistance struct array, Durability, Weight, GetResistance() query. Referenced by BPC_DamageReceptionSystem (72).

System 131 — DA_StateGatingTable
Header Source/Framework/Public/State/DA_StateGatingTable.h
Source Source/Framework/Private/State/DA_StateGatingTable.cpp
Parent UPrimaryDataAsset
Blueprint Child Not needed — create one Data Asset instance with 37 gating rules

Provides FStateGatingRule struct (ActionTag, BlockedByState, bIsBlocked), IsActionGated() query. Referenced by BPC_StateManager (130).

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 UInterfaces 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
08 UBPC_HealthSystem UActorComponent Yes — BP child implements logic None
09 UBPC_StaminaSystem UActorComponent Yes — BP child implements logic None
10 UBPC_StressSystem UActorComponent Yes — BP child implements logic None
11 UBPC_MovementStateSystem UActorComponent Yes — BP child implements logic 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
75 UBPC_HitReactionSystem UActorComponent Yes — BP child implements logic None
79 UBPC_ShieldDefenseSystem UActorComponent Yes — BP child implements logic None
120 UDA_EquipmentConfig UPrimaryDataAsset No — create per-item instances None
128 USS_EnhancedInputManager UGameInstanceSubsystem No — auto-created None
130 UBPC_StateManager UActorComponent No — add to pawn directly None
131 UDA_StateGatingTable UPrimaryDataAsset No — create one Data Asset instance None
— APC_CoreController APlayerController Yes — PC_CoreController BP child Set in GameMode defaults
— APS_CorePlayerState APlayerState Yes — PS_CorePlayerState BP child Set in GameMode defaults

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 UGameInstanceSubsystems. UE creates them automatically when the GameInstance initializes. No spawning, no placement, no BeginPlay required.

Systems marked "Yes — BP child implements logic" are C++ stubs that exist solely for UHT resolution. The stubs provide the necessary UCLASS definition and basic properties/dispatchers. The full gameplay logic lives in the Blueprint child.

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_HealthSystem (stub)        ← No C++ dependencies
 9. BPC_StaminaSystem (stub)       ← No C++ dependencies
10. BPC_StressSystem (stub)        ← No C++ dependencies
11. BPC_MovementStateSystem (stub) ← No C++ dependencies
12. PC_CoreController / PS_CorePlayerState (stubs) ← No C++ dependencies
13. DA_EquipmentConfig (stub)      ← No C++ dependencies
14. BPC_InventorySystem            ← Needs DA_ItemData
15. SS_SaveManager                 ← Needs GI_GameFramework
16. BPC_DamageReceptionSystem     ← Needs DA_EquipmentConfig, DA_ItemData
17. BPC_HitReactionSystem (stub)   ← No C++ dependencies
18. BPC_ShieldDefenseSystem (stub) ← No C++ dependencies
19. SS_EnhancedInputManager       ← No C++ framework deps (EnhancedInput plugin only)
20. BPC_StateManager              ← Needs DA_StateGatingTable, BPC_HealthSystem, BPC_StaminaSystem, BPC_StressSystem, BPC_MovementStateSystem
21. DA_StateGatingTable (stub)     ← No C++ dependencies

Note: Stub classes have zero C++ dependencies and can be built in any order before the systems that reference them. Build them first to satisfy UHT forward-declaration resolution.

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 BPC_* specs except the 4 fully converted C++ classes (InventorySystem, DamageReceptionSystem, StateManager, EnhancedInputManager) and the 8 stub classes listed 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.