Module Guide — What Each System Does

Buyer-friendly breakdown of every module. For each system: what it does, what you can build with it, and what it explicitly does NOT do. No surprises.

What is WC RPG Worlds?

WC RPG Worlds is a complete game framework plugin for Unreal Engine 5. It ships everything a studio needs to build a fully-featured RPG without writing thousands of lines of boilerplate. Combat, inventory, GAS attributes, skill trees, AI, quests, dialogue, interaction, save/load, UI, factions, audio — all fully implemented, integrated, and multiplayer-tested.

Think of it as the engine below your engine. The framework handles networking, replication, GAS wiring, UI data binding, and every systemic problem that normally consumes months. You focus on your game's unique content and logic.

Prerequisites

Installation — Step by Step

MyRPGGame/
  MyRPGGame.uproject
  Source/
  Content/
  Plugins/
    DynamicRPGWorlds/          ← copy here
      DynamicRPGWorlds.uplugin
      Source/
        WCGASCore/
        WCCombat/
        ... (23 module folders)

{
  "FileVersion": 3,
  "EngineAssociation": "5.7",
  "Category": "",
  "Description": "",
  "Modules": [ ... ],
  "Plugins": [
    { "Name": "DynamicRPGWorlds", "Enabled": true },
    { "Name": "GameplayAbilities", "Enabled": true },
    { "Name": "EnhancedInput", "Enabled": true },
    { "Name": "ModelViewViewModel", "Enabled": true },
    { "Name": "Mover", "Enabled": true }
  ]
}

Framework Philosophy

The 6 Golden Rules

Glossary

System Architecture

Complete architectural reference — layer model, module dependency graph, data flows, and class hierarchies.

Module Layer Model

The framework is organized into 4 strict layers. Dependencies flow upward only. Violating this creates compilation order bugs and circular dependencies.

Module Dependency Graph

GAS Integration Architecture

// ASC ownership differs between player and AI characters

// PLAYER: ASC lives on PlayerState (survives respawn)
AWCPlayerState
  ├─ UWCCombatAbilitySystemComponent  (ASC — replicated via PlayerState)
  ├─ UWCGASAttributeRegistry          (maps 150 pool slots to definitions)
  ├─ UWCInventoryComponent
  ├─ UWCEquipmentComponent
  ├─ UWCStoriesComponent              (quest tracking)
  ├─ UWCKnowledgeComponent            (achievements, codex, bestiary)
  └─ UWCExplorationComponent          (discovered locations)

AWCMoverPlayerCharacter             (avatar — ASC owner is PlayerState)
  └─ UWCInteractionComponent

// AI: ASC lives on the character directly (simpler ownership)
AWCMoverAICharacter
  ├─ UWCCombatAbilitySystemComponent  (ASC — owned by character)
  └─ UWCGASAttributeRegistry

// IAbilitySystemInterface is implemented on both — GetAbilitySystemComponent()
// works uniformly regardless of where the ASC lives

Input Pipeline Architecture

Physical Key / Controller Button
  → Unreal Enhanced Input System (InputAction triggered)
    → UWCInputManagerComponent (on AWCPlayerController)
      → Sort registered handlers by Priority (0=Critical → 400=Background)
        → Handler[0].CanHandleInput(Context)?
          YES → Handler[0].OnInputTriggered(Context) → consumed, stop
          NO  → Handler[1].CanHandleInput(Context)?
               ...continue down priority list...
        → No handler consumed?
          → bAllowBuffering=true? → push to UWCInputBuffer
            → UWCComboDetector evaluates buffer against UWCComboDefinitions
              → Match found → ActivateAbilityByTag(ComboAbilityTag)
              → No match   → ActivateAbilityByTag(FallbackAbilityTag)

Save / Load Pipeline Architecture

// SAVE FLOW (async, non-blocking)
WCSaveSubsystem::SaveGameAsync(SlotIndex)
  → Apply GAS tag: WC.Save.State.SavingDisabled (blocks abilities during save)
  → UWCSaveSubsystem::SerializeWorld(WorldSection)
    ├─ UWCWorldStateSubsystem::CaptureWorldSnapshot()
    ├─ UWCCalendarSubsystem::SerializeTime()
    └─ For each dynamic actor → GetActorSaveData()
  → For each PlayerController → SerializePlayer(PlayerSection)
    ├─ UWCGASAttributeRegistry::SerializeAttributeState()
    ├─ UWCInventoryComponent::SerializeForSave()
    ├─ UWCEquipmentComponent::SerializeForSave()
    ├─ UWCStoriesComponent::SerializeForSave()
    ├─ UWCKnowledgeComponent::SerializeForSave()
    └─ UWCExplorationComponent::GetDiscoveredLocations()
  → AsyncSaveGameToSlot(SaveGameObject, SlotName)
  → Remove GAS tag: WC.Save.State.SavingDisabled

// LOAD FLOW
WCSaveSubsystem::LoadGameAsync(SlotIndex)
  → Apply GAS tag: WC.Save.State.Loading
  → AsyncLoadGameFromSlot
  → RestoreWorldSection()
    ├─ UWCCalendarSubsystem::DeserializeTime()
    ├─ UWCWorldStateSubsystem::RestoreWorldSnapshot()
    └─ Respawn / restore dynamic actors via QuickLookupMap
  → For each saved player → RestorePlayer()
    ├─ Match by NetID (listen host) or index 0 (dedicated server)
    ├─ UWCGASAttributeRegistry::DeserializeAttributeState()
    ├─ UWCInventoryComponent::DeserializeFromLoad()
    ├─ UWCEquipmentComponent::DeserializeFromLoad()
    ├─ UWCStoriesComponent::DeserializeFromLoad()
    ├─ UWCKnowledgeComponent::DeserializeFromLoad()
    └─ UWCExplorationComponent::SetDiscoveredLocations()
  → Remove GAS tag: WC.Save.State.Loading

Character Class Hierarchy

ACharacter (UE base)
  └─ AWCCharacterBase              // DynamicRPGWorlds — common state, death handling
       ├─ AWCMoverPlayerCharacter  // Player — ASC on PlayerState
       └─ AWCMoverAICharacter      // AI base — ASC on self
            ├─ AWCNPCCharacter     // Standard NPC (in WCAI Private/)
            └─ AWCBossNPCCharacter // Boss NPC with bridge to WCDynamicSociety

AMoverCharacterBase (Mover Plugin)
  └─ AWCMoverCharacterBase         // WC Mover bridge base
       ├─ AWCMoverPlayerCharacter
       └─ AWCMoverAICharacter

Data Asset Hierarchy

UPrimaryDataAsset (UE base)
  ├─ UWCItemDefinition             // Immutable item template + fragments array
  ├─ UWCAbilityDefinition          // Ability template + ability fragments
  ├─ UWCGASAttributeDefinition     // Attribute definition (pool slot assignment)
  ├─ UWCGASHeritageRaceData        // Race definition (modifiers, restrictions)
  ├─ UWCGASHeritageClassData       // Class definition (skill trees, abilities)
  ├─ UWCComboDefinition            // Combo input sequence → ability tag
  ├─ UWCInteractionData            // Interactable configuration
  ├─ UWCMusicStateDefinition       // Music layer configuration
  ├─ UWCQuestDefinition            // Quest template (in WCStories)
  ├─ UWCDialogueDefinition         // Dialogue tree (in WCStories)
  ├─ UWCFactionDefinition          // Faction config (in WCDynamicSociety)
  └─ UWCInputSetupData             // Handler pipeline configuration

UObject (runtime instances — NOT data assets)
  ├─ UWCItemInstance               // Runtime item (refs its Definition, holds state)
  └─ UWCAbilitySpec                // Standard GAS ability spec

Complete Module Status (March 31, 2026)

Step-by-Step Tutorials

12 complete walkthroughs. Follow in order. By the end you will have a fully playable RPG Slice not a full game.

Tutorial 1: Your First Character

Tutorial 2: Attributes (Health, Mana, Stamina)

// Option A: Get Player State -> Get WC ASC -> Get Attribute Value(DA_Attr_Health)
// Option B: WCCoreLibrary::GetAttributeValue(Actor, DA_Attr_Health)

Tutorial 3: Your First Item (Health Potion)

GetPlayerState -> GetInventoryComponent -> AddItem(DA_Item_HealthPotion, 3)

InventoryComponent -> UseItem(ItemInstance)
// Applies GE, reduces stack, removes if empty

Tutorial 4: Melee Weapon and Combat

Tutorial 5: Enemy AI

Tutorial 6: Interaction (Chest / Door / NPC)

Tutorial 7: Heritage (Race and Class)

Tutorial 8: MVVM UI - Health Bar

WCUIManagerSubsystem -> PushLayer(WBP_HealthBar, EWCUILayer::HUD)
WBP_HealthBar -> SetViewModel(Create VM_HealthBar -> Init(PlayerASC))

Tutorial 9: Quests

StoriesComponent -> AcceptQuest(DA_Quest_KillGoblins)
// On goblin death (combat event fires WC.Enemy.Goblin tag):
StoriesComponent -> UpdateObjectiveProgress(Quest, Index:0, Delta:1)

// When OnQuestReadyToComplete fires:
StoriesComponent -> CompleteQuest(DA_Quest_KillGoblins)
// Applies all rewards, moves to CompletedQuests

Tutorial 10: Skill Tree

WCGASSkillTreeComp -> AddSkillPoints(1)   // on level up
WCGASSkillTreeComp -> UnlockNode(DA_Skill_PowerStrike)
// validates prereqs + SP cost, grants ability if pass

Tutorial 11: Factions and Social System

WCDynamicSocietySubsystem -> GetRelationshipCategory(Actor, Actor)
// returns Hostile/Neutral/Friendly/Allied
WCDynamicSocietySubsystem -> ModifyRelationship(Player, FactionTag, +15.0)

Tutorial 12: Save and Load

Get WCSaveSubsystem (from GameInstance)
  -> SaveGameAsync(SlotIndex: 0)
// Serializes: attributes, inventory, equipment, quests,
// knowledge, exploration, world state, calendar. All automatic.

WCSaveSubsystem -> LoadGameAsync(SlotIndex: 0)
WCSaveSubsystem -> GetSaveSlots()  // list available slots
WCSaveSubsystem -> GetSlotInfo(0)  // timestamp, level, playtime

WCSaveSubsystem -> SaveForLevelTransition()  // synchronous
Open Level (NextLevelName)
// WCGameInstance automatically restores state after travel

Systems Deep Dive

Complete technical documentation for every major system. Assumes you have completed the tutorials.

GAS Core (WCGASCore)

WCGASCore is the foundation of every other module. It provides the 150-slot attribute pool, all 348 native gameplay tags, the MMC library, and the AbilityLibrarySubsystem.

Attribute Pool

Instead of writing custom AttributeSets, WCGASCore provides 150 pre-allocated, replicated attribute slots on a single UWCAttributeSet. At runtime, UWCGASAttributeRegistry assigns Data Asset definitions to slots. Each slot gets a base value, min, max, clamp mode, and optional regen config.

// Reading an attribute (any module, any context):
float Health = WCGASAttributeRegistry->GetAttributeValue(Actor, DA_Attr_Health);

// Writing via GE (always go through GAS, never set directly):
ASC->ApplyGameplayEffectToSelf(GE_HealPlayer, 1.0f, ASC->MakeEffectContext());

// Binding to changes:
WCGASAttributeRegistry->BindToAttributeChanged(DA_Attr_Health, 
    FWCAttributeChangedDelegate::CreateUObject(this, &MyClass::OnHealthChanged));

Gameplay Tags (348 Native Tags)

All tags are declared in WCGameplayTags.h using UE_DECLARE_GAMEPLAY_TAG_EXTERN and defined in WCGameplayTags.cpp using UE_DEFINE_GAMEPLAY_TAG. Tags are organized by domain:

MMC Library (12 Formula Types)

Modifier Magnitude Calculations allow attribute-scaled GE magnitudes. WCGASCore provides 12 pre-built MMCs:

GAS Ally System (WCGASAlly)

WCGASAlly is the largest module (425 files). It provides the full RPG character layer: Heritage (race/class), StatusEffects, SkillTree, Damage/Healing formulas, Resistance, Leveling, Feats, and WorldContext.

StatusEffect System

StatusEffects are persistent gameplay effects with stacking, duration tracking, and full save/load support. They differ from standard GEs in that they have visual/audio components, stack limits, and cleansing interactions.

// Apply a status effect:
WCGASStatusEffectComp->ApplyStatusEffect(DA_StatusEffect_Poison, SourceActor);

// Query active effects:
WCGASStatusEffectComp->GetActiveStatusEffects(OutEffects);

// Cleanse by tag:
WCGASStatusEffectComp->CleanseStatusEffectsWithTag(WC.StatusEffect.Type.Poison);

// Configure in Data Asset:
DA_StatusEffect_Poison:
  GE To Apply:        GE_Poison_Tick
  Duration:           10.0 seconds
  Tick Rate:          1.0 second
  Max Stacks:         3
  Stack Behavior:     RefreshDuration    (or AddDuration, ReplaceDuration)
  Cleanse Tags:       [WC.StatusEffect.Immunity.Poison]
  Visual Effect:      NiagaraSystem_PoisonCloud
  Sound:              SFX_PoisonTick

Feat System

Feats are milestones unlocked by meeting conditions (level reached, stat threshold, achievement). Each feat provides a passive bonus or ability unlock. UWCGASFeatComponent manages the feat pool, pending selections, and save/restore.

// Feat selection (UI calls this after player picks):
WCGASFeatComp->SelectFeat(DA_Feat_CriticalStrike);

// Check if feat is unlocked:
WCGASFeatComp->IsFeatUnlocked(DA_Feat_CriticalStrike);  // bool

// Feats that unlock on milestone:
DA_Feat_IronSkin:
  Display Name:    "Iron Skin"
  Unlock Condition: Level >= 10
  Bonus GE:        GE_Feat_IronSkin_PhysResist (+15 Physical Resistance)
  bGrantAbility:   false

Leveling System

The leveling system is curve-driven. Each level-up fires events, grants skill points, and triggers feat milestone checks.

// Add XP (triggers level up if threshold met):
WCGASAllyComp->AddExperience(500.0f);

// Configure the XP curve:
Project Settings -> Dynamic RPG Worlds -> GAS Ally -> XP Curve
// UCurveFloat where X=Level, Y=XP required to reach that level

// Level up event (BP override):
Event OnLevelUp(NewLevel)
  -> WCGASSkillTreeComp->AddSkillPoints(1)
  -> WCGASFeatComp->CheckMilestones(NewLevel)
  -> Play level up VFX/SFX

Combat System (WCCombat)

WCCombat handles melee, ranged, aimed, charge, reload, scope, and weapon swap — all GAS-native, fully replicated.

Melee Hit Detection

Hit detection uses WCAnimNotifyState_MeleeTrace which sphere-sweeps between two bone sockets every tick during the notify window. Hits are batched per swing to prevent multiple registrations on the same target.

// The trace fires automatically via the AnimNotify.
// The combat ability handles the hit via:
OnMeleeHit(FWCTargetData_MeleeHit& HitData)
  -> Validate: HasAuthority? In trace window? Target alive?
  -> Build damage spec from weapon fragments + ability modifiers
  -> Apply FinalMultiplier from equipment
  -> ApplyGameplayEffectSpecToTarget(DamageSpec, Target)
  -> Fire WC.Combat.Event.Hit gameplay event for VFX/SFX routing

Ranged / Projectile System

// WCGameplayAbility_Ranged fires projectiles:
DA_Ability_ArrowShot (UWCAbilityDefinition):
  AbilityClass: UWCGameplayAbility_Ranged
  Fragment: UWCAbilityFragment_RangedCombat
    Projectile Class:   BP_WCArrowProjectile
    Launch Socket:      bow_string
    Spread:             2.0 degrees
    Max Range:          5000 cm
    bPierce:            false
    bHomingEnabled:     false
    DamageGE:           GE_ArrowDamage (uses FinalMultiplier)

Combo Attack Chain vs Combo Tree

Weapon Swap System

// Swap weapon in main hand:
EquipmentComp->SwapWeapon(NewWeaponInstance, EWCEquipSlot::MainHand);
// 1. Unequip current: removes equipped GEs, revokes granted abilities
// 2. Play unequip montage (WCAnimNotify_WeaponUnwield)
// 3. Equip new: applies equip GEs, grants abilities
// 4. Play equip montage (WCAnimNotify_WeaponWield)

Input System (WCInput)

Handler Priority Reference

Complete Handler List (11 handlers)

Creating a Custom Handler

UCLASS()
class UMyCustomInputHandler : public UWCInputHandler
{
    GENERATED_BODY()
public:
    virtual bool CanHandleInput(const FWCInputHandlerContext& Ctx) const override
    {
        // Return true if this handler should process this input
        return Ctx.InputAction == IA_MyCustomAction;
    }
    virtual bool OnInputTriggered(const FWCInputHandlerContext& Ctx) override
    {
        // Do your logic here
        // Return true = input consumed, stop routing down priority list
        return true;
    }
};

// Register at runtime (e.g., on PlayerController BeginPlay):
UWCInputManagerComponent* IMC = Controller->GetInputManager();
IMC->RegisterHandler(NewObject(), 200 /*priority*/);

Interaction System (WCInteraction)

Interaction Types

Detection Modes

UI Framework (WCUIFramework)

Screen Layer Stack

// Layers (from back to front):
EWCUILayer::World      // 3D widgets, nameplates
EWCUILayer::HUD        // Health bars, crosshair, ability cooldowns
EWCUILayer::Menu       // Inventory, map, character screen
EWCUILayer::Modal      // Confirmation dialogs, notifications
EWCUILayer::Loading    // Loading screens (always on top)

// Layer operations:
WCUIManagerSubsystem->PushLayer(WidgetClass, EWCUILayer::Menu);
WCUIManagerSubsystem->PopLayer(EWCUILayer::Menu);
WCUIManagerSubsystem->GetLayerWidget(EWCUILayer::HUD);  // returns UUserWidget*
WCUIManagerSubsystem->IsLayerVisible(EWCUILayer::Modal);

Theme System

// All UI colors, fonts, and sizes come from UWCUITheme data asset:
Project Settings -> Dynamic RPG Worlds -> UI -> Active Theme

// Access in widgets:
UWCUISubsystem->GetCurrentTheme()->PrimaryColor   // FLinearColor
UWCUISubsystem->GetCurrentTheme()->BodyFont        // FSlateFontInfo
UWCUISubsystem->GetCurrentTheme()->BorderBrush     // FSlateBrush

// Switch themes at runtime (for accessibility modes):
WCUIManagerSubsystem->SetTheme(DA_Theme_HighContrast);

Tooltip System

// Tooltips appear after hover delay and track cursor/anchor:
WCTooltipManager->ShowTooltip(WidgetClass, AnchorWidget, Delay: 0.5f);
WCTooltipManager->HideTooltip();
WCTooltipManager->SetDelay(0.3f);    // global hover delay

// Item tooltips aggregate from fragments automatically:
// WCFragment_Rarity    -> rarity color + name
// WCFragment_Equippable -> slot requirement line
// WCFragment_AttributeModifiers -> stat comparison lines vs equipped item
// WCFragment_WeaponData -> damage range, type

Dynamic Society System (WCDynamicSociety)

WCDynamicSociety (188 files) provides the full social simulation: factions, relationships, crime/justice, calendar, and personality-driven NPC behavior.

Social Architecture

Calendar System

// Get current in-game time:
WCCalendarSubsystem->GetCurrentTime()   // returns FWCDateTime
WCCalendarSubsystem->GetTimeOfDay()     // EWCTimeOfDay (Dawn/Day/Dusk/Night)
WCCalendarSubsystem->GetSeason()        // EWCSeason (Spring/Summer/Autumn/Winter)
WCCalendarSubsystem->GetDayOfWeek()     // EWCDayOfWeek

// Advance time (for fast travel etc.):
WCCalendarSubsystem->AdvanceTime(Hours: 8.0f);

// Bind to time events:
WCCalendarSubsystem->OnDayChanged.AddDynamic(this, &MyClass::OnNewDay);
WCCalendarSubsystem->OnHourChanged.AddDynamic(this, &MyClass::OnHourTick);
WCCalendarSubsystem->OnSeasonChanged.AddDynamic(this, &MyClass::OnSeasonChange);

Crime System

// Commit a crime (called by game logic when player does bad thing):
WCCrimeSubsystem->RecordCrime(Player, WC.Society.Crime.Assault, Victim, Location);

// Query wanted level:
WCCrimeSubsystem->GetWantedLevel(Player)   // 0..5 (5 = shoot on sight)
WCCrimeSubsystem->GetBounty(Player)        // in-game gold value

// Pay bounty at guard:
WCCrimeSubsystem->PayBounty(Player, Guard);

// Crime evidence decays over time automatically
// Guards respond based on wanted level and faction standing

Realms System (WCRealms)

Level Streaming

// Load a realm (level streaming area):
WCLevelStreamingSubsystem->RequestLoadRealm(DA_Realm_CityCenter, TransitionType: Seamless);
// PendingRealm / PendingLevelsToLoad tracked internally until streaming completes

// Fast travel:
WCFastTravelSubsystem->FastTravelTo(DA_Location_InnTavern);
// Validates: is location discovered? enough gold? time of day allowed?
// Advances calendar by travel time
// Loads destination level

// Discovery:
WCDiscoverySubsystem->DiscoverLocation(DA_Location_AncientRuins);
WCDiscoverySubsystem->IsLocationDiscovered(DA_Location_AncientRuins);

// Location volumes (place in level):
AWCLocationVolume - trigger volume that fires discovery event on overlap

Audio Suite (WCAudioSuite)

// Request music transition (crossfade between states):
WCAudioSuiteSubsystem->RequestMusicTransition(DA_MusicState_Combat);
// Spawns UAudioComponent per layer, fades out old, fades in new
// CrossfadeInTime / CrossfadeOutTime set in DA_MusicState

// Play stinger (one-shot musical hit):
WCAudioSuiteSubsystem->PlayStinger(DA_Stinger_VictoryFanfare, bIs3D: false);
// 2D: SpawnSound2D | 3D: SpawnSoundAttached to actor

// Ambient zones (push/pop stack):
WCAudioSuiteSubsystem->PushAmbientZone(DA_AmbientZone_Dungeon);
WCAudioSuiteSubsystem->PopAmbientZone(DA_AmbientZone_Dungeon);

// Layer volume control:
WCAudioSuiteSubsystem->SetLayerVolume(EWCAudioLayer::Music, 0.8f);
WCAudioSuiteSubsystem->SetLayerVolume(EWCAudioLayer::SFX, 1.0f);
WCAudioSuiteSubsystem->SetLayerVolume(EWCAudioLayer::Voice, 1.0f);
WCAudioSuiteSubsystem->SetLayerVolume(EWCAudioLayer::Ambient, 0.6f);

Knowledge Suite (WCKnowledgeSuite)

// ACHIEVEMENTS
WCKnowledgeComp->UnlockAchievement(DA_Achievement_FirstBlood);
WCKnowledgeComp->GetAchievementProgress(DA_Achievement_KillCount); // returns float
WCKnowledgeComp->IsAchievementUnlocked(DA_Achievement_FirstBlood); // bool

// CODEX (lore entries unlocked by discovery)
WCKnowledgeComp->UnlockCodexEntry(DA_Codex_GoblinLore);
WCKnowledgeComp->GetCodexEntry(DA_Codex_GoblinLore); // returns FWCCodexEntry

// BESTIARY (enemy info unlocked by combat encounters)
WCKnowledgeComp->RecordBestiaryKill(WC.Enemy.Goblin);
WCKnowledgeComp->GetBestiaryEntry(WC.Enemy.Goblin); // FWCBestiaryEntry

// TUTORIALS (guided hints system)
WCKnowledgeComp->MarkTutorialComplete(DA_Tutorial_FirstCombat);
WCKnowledgeComp->ShouldShowTutorial(DA_Tutorial_FirstCombat); // bool

// All 4 systems serialize/deserialize via WCSaveSystem automatically

AI System (WCAI)

Built-in BT Tasks

Built-in BT Services

Routine Goals (12 built-in)

// NPC daily routines driven by calendar:
WC.AI.Routine.Patrol       - walk patrol points
WC.AI.Routine.Sleep        - go to bed location, idle
WC.AI.Routine.Trade        - move to market, barter behavior
WC.AI.Routine.Pray         - move to shrine, idle
WC.AI.Routine.Guard        - stand guard post (placeholder - deferred)
WC.AI.Routine.Eat          - move to food source, idle
WC.AI.Routine.Socialize    - move to social area, approach NPCs
WC.AI.Routine.Work         - move to work site, labor animation
WC.AI.Routine.Flee         - emergency flee from threat
WC.AI.Routine.Combat       - engage hostile target
WC.AI.Routine.Investigate  - move to last known position of threat
WC.AI.Routine.Idle         - default do-nothing state

All 23 Modules

Click any module header to expand full details, classes, and implementation notes.

Layer 1 - Foundation

Layer 2 - Feature Modules (14 runtime)

Layer 3 - Integration

Multiplayer Guide

Complete guide to multiplayer architecture, replication rules, authority patterns, and testing. The framework is multiplayer-native — every system was designed with networking in mind from day one.

Replication Architecture

WC RPG Worlds uses standard UE authority model: the server is authoritative for all game state. Clients send input, server validates and executes, replicates results back to clients.

ASC Ownership Patterns

// PLAYER: ASC on PlayerState (persists through respawn)
AWCPlayerState (replicated to all clients)
  -> UWCCombatAbilitySystemComponent (ASC)
AWCMoverPlayerCharacter (avatar)
  -> GetAbilitySystemComponent() returns PlayerState ASC via IAbilitySystemInterface

// AI: ASC on Character (simpler, no respawn requirement)
AWCMoverAICharacter
  -> UWCCombatAbilitySystemComponent (ASC, owned by character)
  -> Destroyed when character dies (acceptable for AI)

RPC Patterns Used in Framework

Common Multiplayer Mistakes to Avoid

• Using TMap for replicated data
  UE cannot replicate TMap. Any replicated collection must be TArray or FFastArraySerializer. Using TMap causes silent data loss on clients. WCGASAlly, WCInventory, WCEquipment all use TArray/FFastArray.
• Directly setting attributes instead of applying GEs
  Attributes must be modified via GameplayEffects on the server. Setting them directly (Attribute.Value = X) bypasses GAS replication and causes server/client divergence. Always: ApplyGameplayEffectToSelf() or ApplyGameplayEffectToTarget().
• Using JumpToSection for attack chains
  JumpToSection is local-only. In multiplayer, use PlayMontage which increments PlayInstanceId and replicates through GAS. The framework handles this automatically via WCGameplayAbility_MeleeAttack - never call JumpToSection in combat abilities.
• Spawning effects on server (visual/audio)
  VFX and SFX should be triggered via Gameplay Cues on clients, not spawned on server. WCCombat routes all cosmetics through WC.GameplayCue.* tags which fire on clients only. Never SpawnSystem2D/SpawnSound on server.
• Cross-module direct references
  A feature module referencing another feature module directly creates compile-time coupling that can cause load order issues in networked games. Always use Tags, Interfaces, or Subsystems for cross-module communication.

Testing Multiplayer

// In Unreal Editor: Play In Editor with multiple clients
Play dropdown -> Number of Players: 2
Net Mode: Play As Listen Server  (or Play As Client for dedicated server)
Enable "Run Dedicated Server" for true dedicated server test

// Useful console commands during MP testing:
net.PacketSimulationSettings.PktLoss 5     // simulate 5% packet loss
net.PacketSimulationSettings.PktLag 100    // simulate 100ms latency
showdebug abilitysystem                    // show GAS debug on screen
wc.save.debug 1                           // enable save system debug log

Dedicated Server Considerations

• WCAudioSuite has NM_DedicatedServer guard in ShouldCreateSubsystem() - no audio subsystem on dedicated server
• WCUIFramework widgets are never created on dedicated server (no PlayerController local role)
• WCSaveSystem uses NetID for player matching on listen server, falls back to index 0 on dedicated server for single-player compatibility
• Cloud save hooks (UploadToCloud/DownloadFromCloud) are BlueprintNativeEvent - override in your GameInstance for your platform (EOS, Steam, etc)
• Add Linux to .uplugin SupportedTargetPlatforms before deploying a dedicated Linux server

Save System Deep Dive

Complete technical reference for WCSaveSystem. 805-line WCSaveSubsystem.cpp — source verified. Handles all 6 cross-module serializers, async pipeline, autosave, level transitions, and cloud hooks.

Save Data Structure

UWCSaveIndex (slot registry):
  TArray<FWCSaveSlotInfo> Slots   // metadata: timestamp, level, playtime

UWCWorldSaveData (per-level):
  TArray<FWCActorSaveRecord> DynamicActors
  FWCWorldSnapshot WorldStateSnapshot
  FWCCalendarSaveData CalendarData

UWCPlayerSaveData (per-player):
  FWCAttributeSaveData GASAttributeData     // pool slot values
  FWCInventorySaveData InventoryData        // item GUIDs + instance state
  FWCInventorySaveData EquipmentData        // slot assignments + GUIDs  
  FWCQuestSaveData QuestData               // active quests + progress
  FWCKnowledgeSaveData KnowledgeData       // achievements, codex, bestiary, tutorials
  TArray<FName> DiscoveredLocations        // exploration map

Complete Save Flow

WCSaveSubsystem::SaveGameAsync(SlotIndex)
  1. HasAuthority() guard - only server saves
  2. bIsSaving = true (prevents concurrent save)
  3. Apply GAS tag: WC.Save.State.SavingDisabled
     -> Blocks abilities tagged BlockedDuringSave
  4. Build UWCWorldSaveData:
     a. UWCWorldStateSubsystem::CaptureWorldSnapshot()
        -> Iterates all IWCSaveable actors -> GetActorSaveData()
     b. UWCCalendarSubsystem::SerializeTime(CalendarData)
  5. For each PlayerController (all connected players):
     Build UWCPlayerSaveData:
     a. UWCGASAttributeRegistry::SerializeAttributeState(GASAttributeData)
        -> Iterates all 150 pool slots, stores current values + base values
     b. UWCInventoryComponent::SerializeForSave(InventoryData)
        -> GUID-ordered TArray of FWCItemSaveRecord
     c. UWCEquipmentComponent::SerializeForSave(InventoryData)
        -> Equipment slot -> item GUID mapping
     d. UWCStoriesComponent::SerializeForSave(QuestData)
        -> Active quest progress + completed quest tag set
     e. UWCKnowledgeComponent::SerializeForSave(KnowledgeData)
        -> Achievements + codex + bestiary + tutorials
     f. DiscoveredLocations = ExplorationComponent::GetDiscoveredLocations()
  6. Compress save data (optional, configurable)
  7. AsyncSaveGameToSlot(SaveGameObject, SlotName, UserIndex)
  8. OnSaveComplete delegate fired
  9. Remove GAS tag: WC.Save.State.SavingDisabled
  10. Update WCSaveIndex slot metadata

Complete Load Flow

WCSaveSubsystem::LoadGameAsync(SlotIndex)
  1. Apply GAS tag: WC.Save.State.Loading
     -> Prevents ability activation during load
  2. AsyncLoadGameFromSlot(SlotName, UserIndex)
  3. OnLoadComplete -> RestoreWorldSection():
     a. UWCCalendarSubsystem::DeserializeTime(CalendarData)
     b. UWCWorldStateSubsystem::RestoreWorldSnapshot(Snapshot)
        -> Finds each actor by GUID in QuickLookupMap
        -> Dynamic actors: Respawn if not found, restore state
        -> Map-placed actors: RestoreFromSaveData() in-place
  4. For each saved PlayerSaveData -> match player:
     Listen server: match by NetID
     Dedicated server solo: use index 0
     a. UWCGASAttributeRegistry::DeserializeAttributeState(GASAttributeData)
     b. UWCInventoryComponent::DeserializeFromLoad(InventoryData)
     c. UWCEquipmentComponent::DeserializeFromLoad(InventoryData)
     d. UWCStoriesComponent::DeserializeFromLoad(QuestData)
     e. UWCKnowledgeComponent::DeserializeFromLoad(KnowledgeData)
     f. ExplorationComponent::SetDiscoveredLocations(DiscoveredLocations)
  5. Remove GAS tag: WC.Save.State.Loading

Level Transition Save

// Synchronous - called before Open Level
WCSaveSubsystem::SaveForLevelTransition()
  -> Same as SaveGameAsync but synchronous (blocks until complete)
  -> Uses a "transition" slot, not the regular numbered slot
  -> UWCGameInstance hooks OnPreLevelTransition automatically

// After level load, WCGameInstance::OnPostLevelTransition:
  -> LoadGameAsync(TransitionSlot)
  -> Restores world section for new level
  -> Restores all player sections

Autosave System

// Configuration:
Project Settings -> Dynamic RPG Worlds -> Save System:
  bEnableAutosave:         true
  AutosaveIntervalMin:     5.0    // minutes of playtime (not real time)
  AutosaveSlotIndex:       0      // which slot autosave uses
  bRetryOnBusy:            true   // retry if save already in progress

// Autosave timer: 1Hz playtime tick in WCSaveSubsystem::Tick()
// Increments PlaytimeAccumulator
// When >= AutosaveIntervalMin * 60:
  -> if bIsSaving: skip this tick, retry next (bRetryOnBusy)
  -> else: SaveGameAsync(AutosaveSlotIndex)

Making Custom Actors Saveable

// Implement IWCSaveable on your actor:
UCLASS()
class AMyDoor : public AActor, public IWCSaveable
{
    GENERATED_BODY()
public:
    virtual void GetActorSaveData(FWCActorSaveRecord& OutData) override
    {
        OutData.ActorGUID = ActorGUID;  // stable GUID assigned at construction
        OutData.Transform = GetActorTransform();
        // Serialize custom state to OutData.CustomData (TArray<uint8>):
        FMemoryWriter Writer(OutData.CustomData);
        Writer << bIsOpen;
        Writer << CurrentLockState;
    }
    virtual void RestoreFromSaveData(const FWCActorSaveRecord& InData) override
    {
        SetActorTransform(InData.Transform);
        FMemoryReader Reader(InData.CustomData);
        Reader >> bIsOpen;
        Reader >> CurrentLockState;
        if (bIsOpen) OpenDoor_NoAnimation();
    }
private:
    FGuid ActorGUID;    // must be stable - assign in constructor or BeginPlay
    bool bIsOpen = false;
    ELockState CurrentLockState = ELockState::Unlocked;
};

Cloud Save Integration

// Override in your GameInstance subclass:
UCLASS()
class UMyGameInstance : public UWCGameInstance
{
    GENERATED_BODY()
public:
    virtual void UploadToCloud_Implementation(
        const FString& SlotName, 
        const TArray<uint8>& SaveData) override
    {
        // Upload SaveData bytes to your cloud service (EOS, Steam, etc.)
        EOSCloudSave::Upload(SlotName, SaveData, OnUploadComplete);
    }
    
    virtual void DownloadFromCloud_Implementation(
        const FString& SlotName,
        FWCCloudSaveResultDelegate OnComplete) override
    {
        EOSCloudSave::Download(SlotName, [OnComplete](TArray<uint8> Data) {
            OnComplete.ExecuteIfBound(Data);
        });
    }
};

Editor Tools Guide

Complete reference for all 8 editor modules. Editor modules ship with the plugin but compile only in editor builds (WITH_EDITOR). They provide Content Browser factories, custom graph editors, and detail panel customizations.

Content Browser Integration

All 8 editor modules register custom Content Browser categories. When you right-click in the Content Browser, you will see a "Dynamic RPG Worlds" top-level category with sub-categories for each system:

Right-click in Content Browser -> Dynamic RPG Worlds ->
  -> GAS (WCGASAllyEditor)      - 40 asset types
  -> Combat (WCCombatEditor)     - combat styles, combos
  -> Society (WCDynamicSocietyEditor) - 31 asset types
  -> Stories (WCStoriesEditor)   - quest, dialogue
  -> Inventory (WCInventoryEditor)    - items, loot tables
  -> Knowledge (WCKnowledgeSuiteEditor) - codex, bestiary, achievements
  -> Interaction (WCInteractionEditor)  - interaction data
  -> Audio (WCAudioSuiteEditor)         - music states, layers

WCGASAllyEditor (86 files, 40 factories)

WCDynamicSocietyEditor (64 files, 31 factories)

WCStoriesEditor (14 files) — Visual Graph Editors

WCStoriesEditor provides two full visual graph editors built on UEdGraph:

Quest Graph Editor

Opens when you double-click a UWCQuestDefinition asset.
Node Types:
  Start Node      - quest accept entry point
  Objective Node  - kill/collect/reach/talk/interact objective
  Branch Node     - condition-based branching (tag check, stat check)
  Reward Node     - item grant, XP, ability unlock
  End Node        - quest completion

Connection Rules (UWCQuestGraphSchema):
  Start -> Objective (required)
  Objective -> Objective (sequential objectives)
  Objective -> Branch (optional branching)
  Branch -> Reward / End
  Reward -> End

Dialogue Graph Editor

Opens when you double-click a UWCDialogueDefinition asset.
Node Types:
  NPC Line Node   - NPC speaks (text, voice, animation hint)
  Player Choice Node - player response options
  Condition Node  - checks tag/stat/quest state
  Consequence Node - changes faction standing, grants item, fires event
  Exit Node       - ends dialogue

The graph is evaluated at runtime by UWCDialogueSubsystem.
Conditions are evaluated per-node before presenting choices to player.

WCCombatEditor (22 files)

Provides:
- UWCCombatStyleFactory: creates combat style data assets
- UWCComboDefinitionFactory: creates combo input sequence assets
- FWCAbilityDefinitionDetailsCustomization: custom Details panel for ability defs
  Adds a visual preview of the ability fragment stack
  Validates fragment compatibility warnings inline

WCInventoryEditor (scaffolding)

Build.cs present. Source directories created. Factory classes declared in headers. Planned 8 factories ready for implementation:

WCKnowledgeSuiteEditor, WCInteractionEditor, WCAudioSuiteEditor

All three created March 31, 2026. Build.cs present, headers declared. Not yet implemented. These unblock designer workflows for creating knowledge, interaction, and audio content directly in the Content Browser.

Quick Reference

The daily cheat sheet. Most-used operations, data asset types, and common Blueprint patterns.

Most-Used Blueprint Operations

Data Asset Quick Reference

Build.cs Module Names (for custom game code)

// In your game modules Build.cs:
PublicDependencyModuleNames.AddRange(new string[] {
    "Core", "CoreUObject", "Engine",
    // WC Framework modules:
    "WCGASCore",          // attributes, tags, MMC
    "WCInventory",        // items, equipment
    "WCCombat",           // combat abilities
    "WCInput",            // input handlers
    "WCInteraction",      // interactables
    "WCUIFramework",      // MVVM, HUD
    "WCGASAlly",          // heritage, skills, feats
    "WCDynamicSociety",   // factions, calendar, crime
    "WCRealms",           // level streaming, discovery
    "WCAudioSuite",       // music, audio layers
    "WCKnowledgeSuite",   // achievements, codex, bestiary
    "WCStories",          // quests, dialogue
    "WCAI",               // AI controllers, BT tasks
    "WCSaveSystem",       // save/load
    "DynamicRPGWorlds",   // integration layer (all classes)
});

// Editor-only tools (wrap in if condition):
if (Target.Type == TargetType.Editor) {
    PrivateDependencyModuleNames.AddRange(new string[] {
        "WCCombatEditor", "WCGASAllyEditor", "WCDynamicSocietyEditor",
        "WCStoriesEditor", "WCInventoryEditor"
    });
}

Most-Used Gameplay Tags

Troubleshooting

Solutions to the most common issues. Check here before creating a support ticket.

Build Errors

• error C2039: identifier not found in WCGameplayTags
  A tag was referenced in a feature module file but not declared in WCGASCore/Public/GAS/WCGameplayTags.h. Solution: Add the tag declaration to WCGameplayTags.h and definition to WCGameplayTags.cpp. Never declare tags in feature modules.
• Circular dependency / module X depends on module Y which depends on X
  A feature module is referencing another feature module directly. Fix: Use interfaces, tags, or subsystems for cross-module communication. Check Build.cs — a feature module should only depend on WCGASCore and UE modules.
• LNK2019 unresolved external / missing DLL export
  A class from a plugin module is being used in game code but the module is not listed in your Build.cs. Add the module name to PublicDependencyModuleNames in your game module's Build.cs.
• IWYU errors: type X is not directly included
  The framework enforces IWYU. Your file uses a type but relies on a transitive include. Add the direct include for the type to your .h or .cpp file. Every file must include exactly what it uses.
• First build fails with "GameplayAbilities module not found"
  GameplayAbilities plugin is not enabled. Open your .uproject, add: { "Name": "GameplayAbilities", "Enabled": true }. Also ensure EnhancedInput, ModelViewViewModel, and Mover are enabled.

Runtime Issues

• Attributes not replicating to clients
  Most common cause: ASC is on the wrong actor. Player ASC MUST be on AWCPlayerState, not the character. The character's GetAbilitySystemComponent() returns the PlayerState ASC. If you created your own PlayerState without inheriting AWCPlayerState, the ASC ownership chain is broken.
• Attack chain not working in multiplayer
  Are you using JumpToSection? That is local-only and breaks replication. The framework uses PlayMontage (which replicates via GAS PlayInstanceId). Do not call JumpToSection on combat montages.
• Interaction prompt not appearing
  Check: (1) UWCInteractableComponent is on the actor, (2) BeginPlay has been called (spatial hash registration happens in BeginPlay), (3) Player has WCInputHandler_Interaction bound to E key, (4) Interaction range in DA_Interact_* is large enough, (5) bCanInteract is true on the component.
• Items disappear after save/load
  Items need stable GUIDs. UWCItemInstance assigns a GUID on creation. If you are creating items via custom code and not going through InventoryComponent::AddItem(), the GUID may not be set. Always use AddItem() to create instances.
• Quest progress resets on load
  WCStoriesComponent::SerializeForSave/DeserializeFromLoad must be called. This happens automatically through WCSaveSubsystem. Check that: (1) WCSaveSystem is in your .uproject plugins list, (2) WCSaveSubsystem has been configured in Project Settings, (3) The player's AWCPlayerState is initialized before load completes.
• Heritage abilities not granted on BeginPlay
  WCGASAllyComponent requires the ASC to be initialized before it can grant abilities. In multiplayer, the ASC on PlayerState initializes asynchronously. The component already handles this via WaitForASCReady internally, but if you have a custom init order, ensure ASC is initialized before calling SetRace/SetClass.
• Music not playing
  WCAudioSuiteSubsystem does not create on dedicated server (NM_DedicatedServer guard). In PIE with dedicated server net mode, no audio subsystem is created. Also check: DA_MusicState has at least one valid USoundWave assigned to a layer.
• WCDynamicSociety faction tags returning wrong results
  After Phase F naming changes (v5), ensure your Blueprint assets have been resaved so CoreRedirects apply. Open the offending Blueprint, compile, save. The 14 CoreRedirects in DefaultEngine.ini handle the renamed enums/structs, but Blueprint assets need one resave to pick them up.

Performance Tips

• Many actors with UWCInteractableComponent causing hitches
  The spatial hash is O(1) for range queries — it is not the issue. Hitches are caused by too many interactables registering in BeginPlay simultaneously (level load). Use async level loading (WCLevelStreamingSubsystem) which spreads BeginPlay calls across frames.
• Save operation causing frame hitch
  WCSaveSubsystem::SaveGameAsync() is async — it should not hitch. If it does, your IWCSaveable::GetActorSaveData() implementations are doing expensive work (raycasting, allocating large arrays). Pre-cache serializable data in variables and just write them in GetActorSaveData().
• BTService_WCTargetScoring running too often
  BTService_WCTargetScoring evaluates all perceived actors every tick by default. Increase its Interval and Random Deviation values in the BT editor. For large enemy counts (100+), set Interval to 0.25s. The scoring itself is O(n) on perceived actor count.
• Attribute regen causing performance issues with many actors
  WCGASRegenerationSubsystem ticks all registered attributes. For AI characters that do not need regen (e.g., simple melee dummies), set bEnableRegen=false on their attribute definitions or use a simpler DA_Attr variant without regen.

Frequently Asked Questions

Gameplay Tags Reference

All 348 native gameplay tags organized by domain. All declared in WCGASCore/Public/GAS/WCGameplayTags.h — zero duplicates verified.

Patterns and Best Practices

Design patterns used throughout the framework and anti-patterns to avoid.

Fragment Pattern (Items and Abilities)

// Item Definition - compose behaviors:
DA_Item_PoisonedDagger:
  Fragments:
    WCFragment_Equippable (MainHand, model)
    WCFragment_WeaponData (Dagger type, trace sockets)
    WCFragment_Rarity (Uncommon)
    WCFragment_AttributeModifiers (+5 Dexterity on equip)
    WCFragment_Consumable_Poison   // custom poison on-hit

// Zero class hierarchy. Mix any fragments.
// Add new behavior = add new fragment class.

// Anti-pattern - do not do this:
class UWCItemDefinition {}
  class UWCWeaponDefinition : UWCItemDefinition {}
    class UWCMeleeWeaponDefinition : UWCWeaponDefinition {}
      class UWCDaggerDefinition : UWCMeleeWeaponDefinition {}
        class UWCPoisonedDaggerDefinition : UWCDaggerDefinition {}

// This creates class explosion, makes cross-cutting
// features impossible, and violates the framework rules.

Cross-Module Communication Pattern

// Good: WCCombat tells other systems about death
// via a Gameplay Event tag:
ASC->AddGameplayEventTag(WC.Combat.Event.Death);

// Any module can listen:
WCKnowledgeComp->ListenForGameplayTag(
    WC.Combat.Event.Death, OnEnemyDied);
WCStoriesComp->ListenForGameplayTag(
    WC.Combat.Event.Death, OnKillObjective);

// BAD - WCCombat directly referencing WCStories:
#include "WCStories/StoriesComponent.h"  // VIOLATION

void UWCCombatSystem::OnKill(AActor* Killed) {
    // Direct reference to another feature module:
    UWCStoriesComponent* Stories = ...;
    Stories->UpdateKillObjective(Killed);  // WRONG
}
// This creates circular dependencies and breaks
// module independence.

Data Asset vs Runtime Instance Pattern

// UWCItemDefinition = the RECIPE (immutable, shared, Data Asset)
//   One instance shared by all copies of "Iron Sword"
//   Stored in content browser, referenced by soft pointer

// UWCItemInstance = the OBJECT in your inventory
//   Created at runtime, unique GUID, has per-instance state
//   Holds reference to its Definition (not a copy)

// This pattern is used throughout:
// UWCItemDefinition / UWCItemInstance  (inventory)
// UWCAbilityDefinition / FGameplayAbilitySpec (abilities)
// UWCQuestDefinition / FWCActiveQuestData (quests)

Subsystem Pattern

// Feature modules expose services via Subsystems, NOT singletons:

// Access a subsystem anywhere:
UWCSaveSubsystem* SaveSys = World->GetSubsystem<UWCSaveSubsystem>();
UWCDynamicSocietySubsystem* Social = World->GetSubsystem<UWCDynamicSocietySubsystem>();
UWCUIManagerSubsystem* UI = GameInstance->GetSubsystem<UWCUIManagerSubsystem>();

// Never create global/static service objects.
// UE Subsystems are lifecycle-managed, safe to null-check,
// and work correctly with editor PIE and multiplayer.

GAS Cue Pattern (Visual Effects)

// All VFX/SFX use Gameplay Cues (client-side, cosmetic only):
// NEVER spawn VFX on server. Never in ability EndAbility.

// In combat ability, trigger a cue on hit:
FGameplayCueParameters CueParams;
CueParams.Location = HitLocation;
CueParams.Normal = HitNormal;
ASC->ExecuteGameplayCue(WC.GameplayCue.Hit.Physical.Slash, CueParams);

// UGameplayCueNotify_Burst on client:
// -> SpawnNiagaraSystemAtLocation(SwordSlashVFX)
// -> SpawnSoundAtLocation(SwordClangSFX)

// Why: Gameplay Cues fire only on clients, are unimportant
// for server state, and can be skipped if too many.

Attribute Modification Pattern

// ALWAYS modify attributes via GameplayEffect:
void ModifyHealth(AActor* Target, float Delta) {
    // RIGHT:
    UGameplayEffect* GE = NewObject<UGameplayEffect>(GetTransientPackage());
    // ... configure modifiers ...
    ASC->ApplyGameplayEffectToSelf(GE, 1.0f, ASC->MakeEffectContext());

    // WRONG - never do this:
    // AttributeSet->Health.SetCurrentValue(NewValue);  // bypasses GAS replication
}

Anti-Patterns to Absolutely Avoid

• Declaring tags outside WCGASCore
  Declaring UE_DEFINE_GAMEPLAY_TAG in any module other than WCGASCore creates ODR (One Definition Rule) violations. Multiple translation units end up defining the same symbol. Results in linker errors or silent duplicate tag registration.
• Using TMap for replicated data
  UE cannot replicate TMap. Period. Use TArray + binary search or FFastArraySerializer. This mistake causes silent data loss that only manifests in multiplayer.
• Modifying plugin source directly
  Any change to files in Plugins/DynamicRPGWorlds/ will be overwritten by plugin updates. Always subclass in your game code. The framework provides clean extension points via virtual functions, BlueprintNativeEvents, and data-driven customization.
• Accessing ASC directly on character for player characters
  For players, the ASC is on AWCPlayerState, NOT the character. Calling GetAbilitySystemComponent() on the character correctly returns the PlayerState ASC via IAbilitySystemInterface — but only if you use the WC classes. Calling Cast<UAbilitySystemComponent> on a component of the character will find nothing.

Roadmap

Current status and planned work as of March 31, 2026. Priority 1 items block designer workflows. Priority 2 is polish. Priority 3 is optional.

API Reference

Key classes and methods. Click any class header to expand. For full IntelliSense, reference the header files directly in VS2022.