Dynamic RPG Worlds

Overview

Dynamic RPG Worlds is a comprehensive Unreal Engine 5.7+ plugin framework by Wonderscape Creations. It gives you a production-ready foundation for open-world RPGs — covering combat, inventory, interaction, AI, adaptive audio, dynamic NPC society simulation, and more. Every system is built on three pillars:

Prerequisites

Engine & Platform

Required UE Plugins (Auto-Enabled)

The .uplugin file enables these automatically. You do not need to enable them manually:

Installation

1. Install Visual Studio 2022 with the Correct Workload

   Open the Visual Studio Installer. Click Modify on VS 2022, then check "Game development with C++". This installs the MSVC compiler toolchain, Windows SDK, and Unreal-compatible build tools. Without this, the plugin will not compile.

   ⚠️

   If VS 2022 is already installed but you're missing the workload, re-run the installer, click Modify, and add it. A full reinstall is not required.

2. Ensure Your Project is a C++ Project

   Open your project in the Unreal Editor. If the project is Blueprint-only, convert it now:

   • Go to Tools → New C++ Class
   • Select None (Empty Class) as the parent, click Next
   • Name it WCSetup and click Create Class
   • Unreal will generate a Source/ folder and open Visual Studio. You can delete the files afterward — you just needed to trigger the C++ project conversion.

3. Copy the Plugin Folder

   Find or create a Plugins/ folder directly inside your project root (same level as Content/ and your .uproject file). Copy the entire DynamicRPGWorlds folder into it:

   YourProject/
   ├── Content/
   ├── Source/
   ├── Plugins/
   │   └── DynamicRPGWorlds/        ← Place here
   │       ├── DynamicRPGWorlds.uplugin
   │       ├── Source/
   │       └── Docs/
   └── YourProject.uproject

4. Enable the Plugin in the Editor

   Open your project in the Unreal Editor. Go to Edit → Plugins. In the search box type Dynamic RPG Worlds. You will see the plugin listed under "Game Design Framework". Check the Enabled checkbox. Click Restart Now when prompted. The editor will close and reopen.

5. Regenerate Project Files

   Close the Unreal Editor fully. In Windows Explorer, right-click your .uproject file and select "Generate Visual Studio project files". Wait for the process to complete (a progress dialog will appear). This step adds all 13 plugin modules to your Visual Studio solution so they are found by IntelliSense and the compiler.

6. Build the Project

   Open the generated .sln file in Visual Studio 2022. In the toolbar, set the configuration to Development Editor and the platform to Win64. Press Ctrl+Shift+B to build.

   ⚠️

   First compile takes 5–15 minutes. The plugin has 13 modules with hundreds of C++ files. Subsequent builds are incremental and take seconds. The green status bar at the bottom of Visual Studio shows build progress. A successful build ends with "Build: 1 succeeded, 0 failed".

7. Launch the Editor and Verify

   Launch the editor from Visual Studio (press F5) or by double-clicking the .uproject file. After it loads, go to Edit → Project Settings. Scroll the left panel — you should see a "Dynamic RPG Worlds" category with sub-entries: General, GAS Core, Input, Interaction, Inventory, Combat, UI, and Audio. If you see these, the plugin is correctly installed and loaded.

   💡

   If the editor crashes on first load, check the Saved/Logs/YourProject.log file. Search for "Error" or "failed" to identify the module that failed to load. Most first-launch issues are caused by missing VS workload components.

8. Verify Plugin Content is Accessible

   In the Content Browser, click the Settings button (gear icon) in the top-right and enable "Show Plugin Content". You should now see a DynamicRPGWorlds Content folder in the browser. This contains any pre-made data assets or examples shipped with the plugin.

9. Enable Show Engine Content (Optional)

   For GAS-related work, also enable "Show Engine Content" in the same Settings menu. This lets you access engine-level GAS classes like GameplayEffect blueprints and attribute sets when creating your assets.

Quick Start Guide

Follow these steps to go from a blank project to a fully functional WC RPG character — with movement, input, attributes, inventory, and basic combat all working. Budget about 45–60 minutes for your first run.

Step 1 — Create Blueprint Subclasses of WC Framework Classes

It is best practice to create Blueprint subclasses rather than using the WC classes directly. This gives you a place to add custom Blueprint logic later without touching C++.

For each class, go to the Content Browser, right-click in your project folder, and select Blueprint Class. In the "Pick Parent Class" search box, search for the class name:

Step 2 — Assign Framework Classes in Project Settings

Go to Edit → Project Settings → Maps & Modes. Under Default Modes, set each class dropdown to the Blueprint you just created:

• Default GameMode: BP_WC_GameMode
• Player Controller Class: BP_WC_PlayerController
• Player State Class: BP_WC_PlayerState
• HUD Class: BP_WC_HUD
• Game State Class: BP_WC_GameState

Open BP_WC_GameMode and in the Details panel, set Default Pawn Class to BP_WC_PlayerCharacter.

Step 3 — Configure Your Player Character Blueprint

1. Open BP_WC_PlayerCharacter

   Double-click it to open. Switch to the Components panel (top-left). You will see components already attached by the parent class: CapsuleComponent (root), Mesh (Skeletal Mesh), WCCharacterMovementComponent, WCInteractionComponent, and WCGASAttributeInitializer.

2. Assign a Skeletal Mesh

   Click on the Mesh component. In the Details panel on the right, find Skeletal Mesh Asset and click the dropdown to select your character's skeletal mesh. Also set the Animation Blueprint (Anim Class) dropdown to your character's Animation Blueprint if you have one.

3. Adjust Capsule Size

   Click the CapsuleComponent. In the Details panel, set Capsule Half Height and Capsule Radius to match your mesh proportions. For a standard human, 88 and 34 are common starting values.

4. Position the Mesh

   The mesh should sit inside the capsule with feet at the bottom. In the viewport, select the mesh and use the transform gizmo to move it down so feet align with the capsule base. Typically a Z offset of -88 (negative half-height) works for standard humanoids.

5. Set Up the Camera

   Add a Spring Arm Component (click Add in the Components panel, search "Spring Arm"). Attach it to the root. Then add a Camera Component attached to the Spring Arm. For a third-person game, set the Spring Arm's Target Arm Length to 400 and enable Use Pawn Control Rotation on the Spring Arm.

Step 4 — Create and Register Attribute Definitions

1. Create Attribute Definition Assets

   In the Content Browser, right-click → Miscellaneous → Data Asset. In the class picker, search for and select WCGASAttributeDefinition. Click Select. Name it DA_WC_Attr_Health. Repeat for Stamina, Mana, and any other stats your game needs.

2. Configure Each Attribute Definition

   Double-click DA_WC_Attr_Health. Fill in the Details panel:

   • Display Name: "Health"
   • Attribute Tag: Click the dropdown and type WC.Attribute.Health — select it from the list (it must be a pre-registered WC tag)
   • Base Value: 100.0 (the starting value for all characters)
   • Min Value: 0.0 — bClampToMin: checked
   • Max Value: 100.0 — bClampToMax: checked
   • bReplicated: checked (health must replicate to all clients)
   • Regen Rate: 0.0 for health (unless you want passive regen), 5.0 for stamina
   • Regen Interval: 0.25 (how often regen ticks, in seconds)

   Click Save. Repeat for each attribute.

3. Register Attributes in Project Settings

   Go to Edit → Project Settings → Dynamic RPG Worlds → GAS Core. Find the Attribute Definitions array. Click the + button for each attribute and assign your DA_WC_Attr_* assets.

Step 5 — Create the Input Setup

1. Create Input Action Assets

   In Content Browser, right-click → Input → Input Action. Create one for each player input:

   • IA_WC_Move — Value Type: Axis2D (Vector2D)
   • IA_WC_Look — Value Type: Axis2D (Vector2D)
   • IA_WC_Jump — Value Type: Digital (bool)
   • IA_WC_Interact — Value Type: Digital (bool)
   • IA_WC_Attack — Value Type: Digital (bool)

2. Create an Input Mapping Context

   Right-click → Input → Input Mapping Context. Name it IMC_WC_Default. Double-click to open it. Click the + button next to Mappings for each Input Action and assign keyboard/mouse keys. For example: IA_WC_Move → WASD keys with Modifiers.

3. Create the WCInputSetupData Asset

   Right-click → Miscellaneous → Data Asset → WCInputSetupData. Name it DA_WC_Input_Default. Open it and configure:

   • Mapping Contexts: Add your IMC_WC_Default, Priority: 0
   • Handlers: Add one handler per input type (see the WCInput module section for handler details)

4. Assign Input Setup to Player Controller

   Open BP_WC_PlayerController. In the Details panel (with nothing selected), find WC | Input → Default Input Setup. Click the dropdown and select your DA_WC_Input_Default asset. This makes the controller apply this input configuration automatically on BeginPlay.

Step 6 — Place a Test Level and Press Play

Open or create a level. Place a Player Start actor. Press Play in the editor. Your character should spawn, and you should be able to move, look around, and jump. Check the Output Log (Window → Output Log) for any warnings. Common early warnings:

• "No attribute definitions registered" — You skipped Step 4.3. Add definitions to Project Settings.
• "Input Setup not found" — You skipped Step 5.4. Assign the setup asset to the controller.
• "WCInteractionComponent: No detection mode set" — Normal until you configure interaction. Can be ignored for now.

Project Settings Reference

All WC Framework settings live under Edit → Project Settings → Dynamic RPG Worlds. Every module registers its own settings category here.

General (WCProjectSettings)

GAS Core (WCGASCoreSettings)

Input (WCInputSettings)

Interaction (WCInteractionSettings)

Inventory (WCInventorySettings)

Combat (WCCombatSettings)

UI (WCUISettings)

Audio (WCAudioSettings)

Module Architecture

The plugin uses a strict 3-layer dependency model. Dependencies flow upward only — lower layers never depend on higher layers.

Naming Conventions

Gameplay Tags

All 161 native gameplay tags live in a single centralized file: WCGASCore/Public/WCGameplayTags.h. The C++ namespace is WCTags::.

// Tag format: WC.[Module].[Category].[Subcategory]
WC.Item.Type.Weapon
WC.Combat.State.InCombat
WC.Combat.Weapon.Type.Melee.Sword
WC.Character.Movement.Sprinting
WC.Input.Action.Attack.Light
WC.State.Gameplay.Exploring

Character Hierarchy

ACharacter (UE Engine)
  └── AWCCharacterBase (Abstract)
      │   — State machine (Normal / Dead / Incapacitated / Cinematic / Spawning)
      │   — Gameplay tag system + DefaultGameplayTags applied on BeginPlay
      │   — Death system: Die() → HandleDeath() → OnDeathFinished()
      │   — GAS integration via IAbilitySystemInterface
      │   Components: WCCharacterMovementComponent, WCInteractionComponent, WCGASAttributeInitializer
      │
      ├── AWCPlayerCharacter
      │     — UGameplayCameraComponent (data-driven rigs via UWCCameraDirector)
      │     — ASC is owned by AWCPlayerState (not the character directly)
      │     — Use this as base for all player-controlled characters
      │
      └── AWCAICharacter
            — Owns WCCombatAbilitySystemComponent directly
            — Use this as base for all NPC/enemy characters

ASC Ownership — Important to Understand

Character States

Module: DynamicRPGWorlds (Integration Core)

Game Framework Classes

Movement System — Locomotion States

Speed modifiers stack multiplicatively via AddSpeedModifier(Tag, Multiplier) / RemoveSpeedModifier(Tag). Use these from abilities and effects to slow or accelerate the character.

Camera System

UWCCameraDirector maps gameplay tags to camera rigs via FWCCameraRigMapping (ActivationTag, CameraRig, Priority). Each frame it reads the player's ASC tags and activates the highest-priority matching rig, falling back to DefaultCameraRig. Use cases: ADS zoom rig, sprint camera, crouch camera, stance cameras.

Module: WCGASCore

Setting Up Attributes — Detailed Steps

1. Create One WCGASAttributeDefinition Per Stat

   For every stat in your game (Health, Stamina, Mana, Strength, Agility, etc.), create a separate Data Asset:

   Content Browser → Right-click → Miscellaneous → Data Asset → WCGASAttributeDefinition

   Use names like DA_WC_Attr_Health, DA_WC_Attr_Stamina, DA_WC_Attr_Mana. Store them in Content/WC/Core/Attributes/.

2. Configure Every Property in the Definition

   Open each attribute definition. Here is every property and what it controls:

   Property	What It Does	Recommended For Health
   DisplayName	Human-readable name shown in UI	"Health"
   AttributeTag	Gameplay tag uniquely identifying this attribute. Must be in WC.Attribute.* hierarchy.	WC.Attribute.Health
   BaseValue	Starting value when an actor is initialized	100.0
   MinValue	Floor — attribute cannot go below this	0.0
   bClampToMin	Enable the minimum clamp	✓ checked
   MaxValue	Ceiling for normal clamping	100.0
   bClampToMax	Enable the maximum clamp	✓ checked
   bReplicated	Replicate this attribute to all clients. Always on for health/mana/stamina shown in UI.	✓ checked
   RegenRate	Amount regenerated per RegenInterval. 0 = no passive regen.	0.0
   RegenInterval	Seconds between regen ticks	0.25
   DegenRate	Amount depleted per tick (for stamina drain during sprint, etc.)	0.0
   UIIcon	Optional icon texture for this attribute in inventory/character screens	Heart texture

3. Register Definitions in Project Settings

   Edit → Project Settings → Dynamic RPG Worlds → GAS Core → Attribute Definitions. Click the + button for each definition asset and assign it. Order matters for pool slot assignment — put frequently-used attributes early in the array.

4. Understand How the Pool Works

   At startup, the WCGASAttributeRegistry reads your definitions array and assigns each one a slot in the pre-generated pool of 150 attributes (Attribute_00 through Attribute_149). So "Health" might become slot 0, "Stamina" slot 1, etc. When an actor is initialized, its WCGASAttributeInitializer creates a WCGASAttributePool AttributeSet and grants it to the ASC — giving that actor all 150 slots, with values initialized from BaseValue.

5. Verify Attributes are Registered

   Press Play. Open the console (~ key) and type: showdebug abilitysystem. Press Enter. In the top-left of the screen you'll see a green overlay listing all attributes registered on the currently possessed pawn's ASC. You should see all your attribute names with their current values. If an attribute is missing, check that it's in the Project Settings array and that the pool size is large enough.

6. Read Attribute Values from Blueprint

   To read an attribute value in a Blueprint (e.g., to show in HUD):

   1. Get the actor's ASC using the GetWCAbilitySystemComponent node
   2. Use the WCGASAttributePoolHelper::GetAttributeValue(ASC, AttributeTag) function, passing the attribute's gameplay tag (e.g., WC.Attribute.Health)
   3. This returns the current value as a float

   For reacting to changes, bind to WCGASAttributePoolHelper::OnAttributeValueChanged(ASC, AttributeTag, Delegate). This fires whenever the attribute changes, including from effects and regen.

7. Configure Attribute Override Per Character (Optional)

   To give a specific NPC different base values than the defaults (e.g., a boss with 500 max health), create a WCGASAttributeOverrideData asset. In it, list which attributes to override and with what values. Assign this asset to the WCGASAttributeInitializer component on that character's Blueprint.

Ability System Classes

Module: WCGASAlly

See the Heritage, Skill Tree, and Calendar walkthroughs in the Walkthroughs section for full step-by-step assembly of these systems.

Module: WCInput

Input Flow

Enhanced Input → WCInputManagerComponent → Handlers (sorted by priority) → InputBuffer → ComboDetector

Setting Up Input — Detailed Steps

1. Create Input Actions for Every Player Input

   For each physical input your game needs, create an Input Action asset (Right-click → Input → Input Action). The value type is critical:

   Input Action	Value Type	Reason
   IA_WC_Move	Axis2D (Vector2D)	WASD or stick produces a 2D direction
   IA_WC_Look	Axis2D (Vector2D)	Mouse delta or right stick produces 2D look
   IA_WC_Jump	Digital (bool)	Simple press/release button
   IA_WC_Interact	Digital (bool)	Simple press/release button
   IA_WC_Attack	Digital (bool)	Simple press/release button
   IA_WC_HeavyAttack	Digital (bool)	Hold detection is handled by the Combat handler
   IA_WC_Dodge	Digital (bool)	Press-only ability activation
   IA_WC_Sprint	Digital (bool)	Hold-to-sprint (handled by Locomotion fragment)
   IA_WC_ToggleInventory	Digital (bool)	Menu toggle press

2. Create an Input Mapping Context

   Right-click → Input → Input Mapping Context. Name it IMC_WC_Default. Open it. For each Input Action, click the + (Add) button and assign your physical keys. Pay attention to Modifiers for WASD axis mapping:

   • IA_WC_Move + W key → Add modifier: Swizzle Input Axis Values (YXZ)
   • IA_WC_Move + S key → Add modifiers: Swizzle Input Axis Values (YXZ) then Negate
   • IA_WC_Move + A key → Add modifier: Negate
   • IA_WC_Move + D key → No modifiers (positive X axis)

3. Create the WCInputSetupData Asset

   Right-click → Miscellaneous → Data Asset → WCInputSetupData. Name it DA_WC_Input_Default. This is the central configuration object that bundles everything together.

4. Add the Mapping Context

   Open DA_WC_Input_Default. In the Mapping Contexts array, click + and assign IMC_WC_Default. Set Priority to 0 (higher numbers take precedence if you have multiple contexts).

5. Add Input Handlers — Movement and Look

   In the Handlers array, click + and choose WCInputHandler_Movement. Configure it:

   • Input Action: IA_WC_Move
   • Priority: 200 (Normal)
   • Blocking Tags: Leave empty unless you want to block movement during specific states (e.g., add WC.State.Gameplay.Cinematic to block movement in cutscenes)

   Add another handler WCInputHandler_Look:

   • Input Action: IA_WC_Look
   • Priority: 200

6. Add the Jump Handler

   Add WCJumpHandler:

   • Input Action: IA_WC_Jump
   • Priority: 200
   • bVariableJumpHeight: true — allows tapping for low jump and holding for high jump (release early to cut jump height)

7. Add the Interaction Handler

   Add WCInputHandler_Interaction:

   • Input Action: IA_WC_Interact
   • Priority: 200
   • This handler automatically finds and calls the WCInteractionComponent on the player character.

8. Add Combat Ability Handlers

   Add WCInputHandler_CombatAbility for attack inputs:

   • Input Action: IA_WC_Attack
   • Priority: 100 (High — combat inputs take precedence over normal)
   • ActionSlotTag: WC.Input.Action.Attack.Light — this tag is what combat styles and weapon fragments use to identify this slot
   • OnPressAbilityTag: Leave empty if you're using a combat style to determine the ability dynamically
   • bGateOnWeaponState: true — only fires when a weapon is drawn
   • bAllowAirborne: true if you want air attacks

   Repeat for heavy attack, dodge, block, and any other combat inputs — each gets its own handler with its own ActionSlotTag.

9. Add Menu Toggle Handler

   Add WCInputHandler_MenuToggle:

   • Input Action: IA_WC_ToggleInventory
   • Priority: 100
   • WidgetClass: Your inventory widget Blueprint (subclass of WCActivatableWidget)
   • LayerTag: The UI layer to push the widget to (e.g., WC.UI.Layer.Menu)

10. Assign Setup to Player Controller and Verify

    Open BP_WC_PlayerController. In Details, set Default Input Setup to DA_WC_Input_Default. Press Play. Enable bDebugInputBuffer in Project Settings temporarily — you'll see a small on-screen overlay showing buffered inputs as you press keys. Press WASD and confirm the character moves. Press Space and confirm the character jumps.

Module: WCInteraction

Setting Up an Interactable Actor — Detailed Steps

1. Understand the Two-Component System

   The interaction system uses exactly two components:

   • WCInteractionComponent — goes on the player character. It scans for nearby interactables using the configured detection mode and shows UI prompts. It is already included on AWCCharacterBase.
   • WCInteractableComponent — goes on any world actor you want to be interactable (door, chest, NPC, lever, etc.).

2. Configure the Player's WCInteractionComponent

   Open your player character Blueprint. Click the WCInteractionComponent in the Components panel. In the Details panel, configure:

   Property	Description	Recommended Value
   DetectionMode	How the player detects interactables	CapsuleTrace for third-person, Trace for first-person
   TraceLength	How far the detection reaches	250cm (matches Project Settings default)
   TraceRadius	Width of the capsule/sphere trace	50cm for CapsuleTrace
   MaxInteractables	How many interactables can be detected at once	3
   WidgetPoolSize	How many interaction prompt widgets to pre-allocate	3
   PromptWidgetClass	The widget Blueprint to show as the interaction prompt	Your subclass of WCInteractionWidget

3. Create the Interactable Actor

   Create or open your world actor Blueprint (e.g., BP_WC_InteractChest). In the Components panel, click Add → WCInteractableComponent. Configure its properties:

   Property	Description	Example Value
   InteractionType	How the interaction is triggered. See types table below.	Instant for chests
   InteractionText	The text shown in the prompt ("Open", "Talk", "Pick Up")	"Open Chest"
   InteractionIcon	Optional icon texture in the prompt	Chest icon texture
   HoldDuration	Only for Hold type — how many seconds to hold	1.5 (irrelevant for Instant)
   MaxInteractors	Max simultaneous interactors (for cooperative)	1 for solo, 2+ for co-op
   RequiredTags	Player must have these tags to interact (e.g., quest started)	Empty for always-available
   BlockedTags	If player has these tags, interaction is blocked	Empty for no restrictions
   bUseInteractionData	Reference a WCInteractionData asset for complex types	false for simple interactions

4. Bind the OnInteractionCompleted Event

   In the actor Blueprint's Event Graph:

   1. Right-click in the graph → search for "Add Event" or "Bind Event to On Interaction Completed"
   2. Select the WCInteractableComponent reference → drag off it and type "On Interaction Completed" → click Bind Event
   3. Create a custom event node (e.g., "OnChestOpened") and connect it to the binding
   4. In your custom event, add the logic: play animation, open the chest lid, spawn loot, play sound, etc.
   💡

   The OnInteractionCompleted delegate passes the Interactor (the actor who triggered it) and the Slot Index (for multi-slot cooperative interactions). Use the Interactor reference to give items to the player who interacted.

5. Enable Debug Visualization to Verify Detection

   In Project Settings → Dynamic RPG Worlds → Interaction, check bEnableDebugVisualization. Press Play. You will see green capsule/sphere debug shapes around your detection area and red/green outlines on interactable actors (red = not in range, green = in range and interactable).

6. Test the Interaction

   Walk up to your interactable actor. You should see the prompt widget appear. Press your interact key (IA_WC_Interact). The OnInteractionCompleted event fires. Check the Output Log — a successful interaction logs: [WCInteraction] Interaction completed on BP_WC_InteractChest by PlayerCharacter.

7. Context-Sensitive Interaction (Optional)

   For interactions that change based on state (a door that shows "Open" when closed and "Close" when open):

   1. Set InteractionType to ContextSensitive
   2. Set bUseInteractionData to true
   3. Create a WCInteractionData asset and assign it. In the asset, define each context with its condition tags and the text/action for that context.
   4. The system automatically evaluates which context applies based on the player's current tags.

8. Interaction with Ability (Optional)

   For interactions that trigger a GAS ability (crafting station, magic portal):

   1. Set InteractionType to Ability
   2. Set InteractionAbilityTag on the component to the ability tag to activate (e.g., WC.Ability.Interaction.Craft)
   3. Add WCAbilityFragment_InteractionMontage to the ability definition if you want a montage to play during interaction

Module: WCInventory

Creating a Complete Weapon Item — Detailed Steps

1. Create the WCItemDefinition Asset

   Right-click → Miscellaneous → Data Asset → WCItemDefinition. Name it DA_WC_Inventory_Item_IronSword and store in Content/WC/Inventory/Items/Weapons/.

2. Set the Base Item Properties

   Open the asset. Fill in the top-level properties:

   • Display Name: "Iron Sword"
   • Description: "A reliable iron sword. Heavy but effective."
   • Icon: Assign your sword thumbnail texture
   • Item Tags: Click the gameplay tag picker and add: WC.Item.Type.Weapon and WC.Item.Type.Weapon.Sword
   • bCanBeDropped: true (can be dropped to the ground)
   • bCanBeSold: true

3. Add WCFragment_Equippable

   In the Fragments array, click + and select WCFragment_Equippable. Configure it:

   Property	Description	Value for Iron Sword
   EquipmentSlot	Which slot this item goes in	WC.Item.Slot.MainHand
   Handedness	OneHanded / TwoHanded / DualWielded	OneHanded
   RequiredLevel	Minimum character level to equip	1
   RequiredTags	Player must have these tags to equip (e.g., class/race restrictions)	Empty (no restriction)
   GrantedAbilities	GAS abilities granted while equipped (e.g., a block ability)	Leave empty for now
   GrantedEffects	GAS effects applied while equipped (e.g., passive damage bonus)	Leave empty for now
   SetTag	Gameplay tag identifying this item's equipment set (for set bonuses)	Empty (no set)

4. Add WCFragment_WeaponData

   Click + in Fragments and select WCFragment_WeaponData:

   Property	Description	Value
   DamageTypeTag	Type of damage this weapon deals	WC.Combat.DamageType.Physical.Slash
   BaseDamage	Flat base damage value before attribute scaling	25.0
   TraceSockets	Array of socket name pairs for melee trace. Add each socket by name. Must exist on your weapon's skeletal mesh.	"WeaponRoot", "WeaponTip"
   WieldedAbilities	Abilities to grant when this weapon is drawn (not just equipped). Use for attack abilities.	Your slash ability tag

   ℹ️

   Finding Socket Names: Open your weapon's Skeletal Mesh in the mesh editor. Click on the Socket Manager (chain link icon in the toolbar). The list shows all sockets. Add "WeaponRoot" at the hilt and "WeaponTip" at the blade tip if they don't exist yet.

5. Add WCFragment_Rarity

   Click + → WCFragment_Rarity. Set RarityTag to WC.Item.Rarity.Common. The rarity system automatically assigns the display color and any rarity-based scaling defined in your WCRarityConfigDataAsset.

6. Add WCFragment_Weight

   Click + → WCFragment_Weight. Set Weight to 3.5 (kilograms). If the weight system is disabled in Project Settings, this fragment is still valid but has no effect.

7. Add WCFragment_EquipmentVisual

   Click + → WCFragment_EquipmentVisual. Configure:

   • StaticMesh or SkeletalMesh: Assign your weapon's mesh asset
   • AttachSocket: The socket on the character skeleton where the weapon attaches in-hand. Common names: hand_r, weapon_r. Check your character's skeleton socket list.
   • HolsterSocket: Where the weapon hangs when sheathed. Common: spine_03 or a custom sword_holster socket.

8. Add WCFragment_AttributeModifiers (Stat Bonuses)

   Click + → WCFragment_AttributeModifiers. In the Modifiers array, click + and configure each bonus:

   • AttributeTag: WC.Attribute.Strength (or whichever stat this sword boosts)
   • Value: 5.0
   • Operation: Add (adds 5 to Strength while equipped)

   Available operations: Add (flat bonus), Multiply (percentage bonus), Override (sets the value directly). These modifiers are automatically applied as a Gameplay Effect when the item is equipped and removed when unequipped.

9. Add WCFragment_WorldRepresentation

   Click + → WCFragment_WorldRepresentation. Set WorldItemClass to AWCStandardWorldItem (or your custom subclass). Optionally assign a WorldMesh that differs from the equipped mesh (e.g., a lower-poly version for the dropped item).

10. Save and Test the Item

    Click Save on the asset. Press Play. Open the console (~) and type your test command to give the item to the player (e.g., a debug Blueprint node calling WCInventoryLibrary::AddItemToInventory(PlayerCharacter, DA_WC_Inventory_Item_IronSword, 1)). Open the inventory UI and verify the sword appears. Try equipping it — the visual mesh should attach to the hand socket, and the attribute bonus should apply (verify with showdebug abilitysystem).

Equipment System Quick Reference

All Item Fragment Types

Module: WCCombat

Setting Up a Combat Style — Detailed Steps

1. Create the WCCombatStyleDefinition Asset

   Right-click → Miscellaneous → Data Asset → WCCombatStyleDefinition. Name it DA_WC_Combat_Style_SwordAndShield. Store in Content/WC/Combat/Styles/.

2. Set Identity Properties

   • StyleTag: WC.Combat.Style.SwordAndShield — unique identifier used to activate/deactivate this style
   • Display Name: "Sword and Shield"
   • Description: "A balanced defensive style with parry and quick thrusts."
   • Icon: Optional icon texture for style display in UI

3. Set Weapon Requirements

   This determines when the style activates based on equipped weapons.

   • WeaponRequirementMode: PerHand — evaluates each hand independently
   • MainHandRequirements: Click the tag query editor. Add condition: Has Tag WC.Item.Type.Weapon.Sword
   • OffHandRequirements: Add condition: Has Tag WC.Item.Type.Weapon.Shield
   • StyleEvaluationMode: Equipped — matches against equipped (not necessarily drawn) weapons. Use Wielded if you only want the style active when weapons are drawn.

4. Map Combat Action Slots to Abilities

   In the CombatActionAbilities array, add one entry per input action:

   Slot Tag	Ability Tag	What it Does
   WC.Input.Action.Attack.Light	WC.Ability.Combat.SwordSlash	Light attack fires the slash ability
   WC.Input.Action.Attack.Heavy	WC.Ability.Combat.ShieldBash	Heavy attack fires the bash ability
   WC.Input.Action.Block	WC.Ability.Combat.Block	Block input activates block ability
   WC.Input.Action.Parry	WC.Ability.Combat.Parry	Parry input activates parry ability

5. Configure Passive Effects (Optional)

   In PassiveEffects, add any Gameplay Effects that should be active while this style is equipped. For example, a shield might grant a passive +20% block chance effect.

6. Configure Anim Layer (Optional)

   If you have a different animation layer for this style (different idle pose, different movement cycle), set the AnimLayerClass to your Animation Blueprint layer subclass. The system will call LinkAnimLayer when the style activates and UnlinkAnimLayer when it deactivates.

7. Register the Style in Project Settings

   Edit → Project Settings → Dynamic RPG Worlds → Combat → Registered Combat Styles. Click + and assign your new DA_WC_Combat_Style_SwordAndShield asset. The combat style subsystem will register it at startup.

   ⚠️

   A style that is not registered in Project Settings will never activate, even if the player equips the correct weapons. Always register new styles.

Combat Animation Notifies

Module: WCUIFramework

Setting Up the Crosshair — Detailed Steps

1. Create a WCCrosshairData Asset

   Right-click → Miscellaneous → Data Asset → WCCrosshairData. Name it DA_WC_UI_Crosshair_Default. This asset defines the visual appearance of the crosshair for your default weapon (or unarmed state).

2. Configure Every Property

   Property	Description	Typical Value
   CenterDotTexture	Texture for the center dot. Leave null for no dot.	Small white dot texture
   SpreadTexture	Texture for the four cardinal spread arms	Thin line texture
   HitMarkerTexture	Texture flashed when a hit is confirmed	X or V shaped texture
   MinSpreadOffset	Distance of spread arms from center at rest	8.0 pixels
   MaxSpreadOffset	Maximum spread distance (full bloom)	40.0 pixels
   SpreadKickAmount	How much spread increases on ShotFired event	15.0
   SpreadKickRandomRange	Randomness added to each kick (visual recoil variation)	3.0
   SpreadRecoveryRate	How fast spread returns to MinSpreadOffset per second	20.0
   HitMarkerDuration	Seconds the hit marker is visible	0.2
   DefaultColor	Default crosshair color	White (1,1,1,1)
   TargetColorOverrides	Tag → color mappings. Add: WC.Character.State.Enemy → Red. WC.Character.State.Friendly → Green.	Depends on game
   OverallScale	Global scale multiplier for the entire crosshair	1.0

3. Create Your HUD Widget Blueprint

   Right-click → Blueprint Class → search WCHUDWidget. Name it WBP_WC_HUD. Open it in the Widget Blueprint editor. The parent class (WCHUDWidget) already handles crosshair spawning and lifecycle. You can add your own widgets (health bar, stamina bar, minimap) directly to this widget.

4. Assign the Default Crosshair Data

   In your HUD Widget Blueprint, select the WCCrosshairWidget child widget. In its Details panel, assign Default Crosshair Data to your DA_WC_UI_Crosshair_Default asset.

5. Register the HUD Widget Class in Settings

   Project Settings → Dynamic RPG Worlds → UI → Default HUD Widget Class. Set it to WBP_WC_HUD. This tells AWCHUD which widget to spawn.

6. Add Weapon-Specific Crosshair Overrides

   For weapons that should show a different crosshair (sniper rifle with scope dots, shotgun with wide spread): add WCFragment_CrosshairData to the weapon's WCItemDefinition. Assign a different WCCrosshairData asset. When that weapon is equipped and drawn, its crosshair data automatically overrides the default.

Module: WCAudioSuite

Setting Up Adaptive Music — Detailed Steps

1. Create Music Layer Definition Assets

   Each music state has multiple audio layers (drums, melody, ambient texture). Create one WCMusicLayerDefinition per layer:

   Right-click → Miscellaneous → Data Asset → WCMusicLayerDefinition. Name it DA_WC_Audio_Layer_Combat_Drums.

   • SoundAsset: Your MetaSound or Sound Wave asset for this layer
   • DefaultVolume: 1.0
   • bLooping: true (music should loop)
   • FadeInDuration: 2.0 seconds
   • FadeOutDuration: 1.5 seconds

2. Create Music State Definition Assets

   One per musical state (Exploration, Combat, Town, Boss, Victory, etc.):

   Data Asset → WCMusicStateDefinition. Name: DA_WC_Audio_State_Combat.

   • StateName: "Combat"
   • Layers: Add all layer definitions for this state (drums, melody, bass)
   • CrossfadeDuration: 2.0 (how long to blend when transitioning to this state)
   • IntroStinger: Optional one-shot sound played when this state activates (e.g., combat horn)
   • OutroStinger: Optional sound played when leaving this state

3. Configure the HUD's Music Director Component

   Open your WBP_WC_HUD Blueprint (or BP_WC_HUD actor Blueprint). Select the WCMusicDirectorComponent. In the MusicStateMappings array, add one entry per state:

   ActivationTag	MusicState	Priority	Notes
   WC.State.Gameplay.Combat	DA_WC_Audio_State_Combat	100	High priority — combat overrides exploration
   WC.State.Gameplay.Exploring	DA_WC_Audio_State_Exploration	10	Default exploration music

   The director evaluates all mappings every frame and activates the highest-priority matching state. Add as many as needed (dungeon, underwater, boss fight, etc.).

4. Set a Default Music State

   On the WCMusicDirectorComponent, set DefaultMusicState to your exploration state. This plays when no gameplay tags match any mapping.

5. Place Ambient Zone Volumes

   In your level, add an AWCAmbientZoneVolume actor (search in Place Actors panel). Scale it to cover your ambient area (forest, cave, town). In its Details, assign a WCAmbientZoneDefinition asset:

   • Create Data Asset → WCAmbientZoneDefinition. Name: DA_WC_Audio_Ambient_Forest.
   • DaySounds: Array of ambient sounds for daytime (birds, wind, insects)
   • NightSounds: Array of ambient sounds for nighttime (crickets, owls)
   • BlendWeight: How strongly this zone's sounds overlay others when stacked

   When the player enters the volume, its definition is pushed to the ambient stack. When they exit, it's popped. Multiple overlapping volumes stack for immersive layering.

6. Set Up Combat Stingers

   Create Data Asset → WCCombatAudioDefinition. In CombatStartStingers, add the sound assets to play when combat begins. In KillStingers, add sounds for kill moments. The system randomly selects from each pool for variety. Assign this asset to WCMusicDirectorComponent → CombatAudioDefinition.

7. Test the Music System

   Press Play. Exploration music should start immediately. Engage in combat (the gameplay state changes to WC.State.Gameplay.Combat). After ~2 seconds of crossfading, the combat music should be active. Kill all enemies — the state returns to Exploring and the music crossfades back. Check Output Log for: [WCMusicDirector] Requesting transition to: Combat.

Module: WCDynamicSociety

See the Calendar & Factions walkthrough section for full assembly steps.

Walkthrough: Your First Melee Ability (Complete)

This walkthrough creates a 3-hit sword combo ability with attack chains, melee trace hit detection, and damage. Start to finish.

1. Create the Damage Gameplay Effect

   Before creating the ability, set up the damage effect that the ability will apply:

   1. Right-click in Content Browser → Blueprint Class → GameplayEffect. Name it GE_WC_Combat_MeleeDamage.
   2. Open it. Set Duration Policy to Instant.
   3. In Modifiers, click +. Set:
      • Attribute: Your health attribute (e.g., WCGASAttributePool.Attribute_00 which maps to Health)
      • Modifier Op: Add
      • Magnitude Calculation Type: Set by Caller
      • Data Tag: Data.Damage
   4. Compile and Save. This effect subtracts the "Data.Damage" value from health when applied.

2. Create the Ability Definition

   Right-click → Miscellaneous → Data Asset → WCAbilityDefinition. Name it DA_WC_Ability_SwordSlash.

   Configure the top-level properties:

   Property	Value	Why
   AbilityTag	WC.Ability.Combat.SwordSlash	Unique identifier used by combat styles and input handlers to reference this ability
   AbilityClass	WCGameplayAbility_Combat	The base combat ability class that supports weapon requirements and combo integration
   InstancingPolicy	InstancedPerActor	Each actor gets its own ability instance, required for per-actor state tracking
   NetExecutionPolicy	LocalPredicted	Client predicts the ability for responsiveness; server validates. Use for all player combat abilities.
   ActivationBlockedTags	WC.State.Gameplay.Dead	Prevent activating while dead
   CancelAbilitiesWithTag	Leave empty	Add tags of abilities this should cancel (e.g., cancel a block ability when attacking)
   CostEffect	Optional — create a GE that subtracts 10 Stamina on activate	Stamina cost per swing
   CooldownEffect	Optional — create a GE with Duration for cooldown	Prevents ability spam

3. Prepare Your Attack Montage

   Open your attack Animation Montage in the editor. If you don't have one, create one from an animation sequence: right-click the animation asset → Create Montage.

   1. In the montage editor, find the Sections panel at the top. Click Add Section three times: name them Attack_01, Attack_02, Attack_03.
   2. Drag the section markers to divide the montage into three equal-ish parts (or at natural animation breakpoints).
   3. In the Notifies track, right-click in the middle of each section's swing phase and select Add Notify State → WCAnimNotifyState_MeleeTrace. Drag its begin/end handles to cover the frames where the blade would cut through the air.
   4. Near the end of each section (with a few frames remaining), right-click and add Notify State → WCAnimNotifyState_AttackChainWindow. Start it about 0.3 seconds before the section ends and let it end at the section boundary. This defines the window where pressing attack again will chain to the next section.

4. Add WCAbilityFragment_MeleeCombat

   Back in DA_WC_Ability_SwordSlash, in the Fragments array, click + and select WCAbilityFragment_MeleeCombat. Configure every property:

   Property	Value	Explanation
   AttackMontage	Your attack montage	The montage that plays when this ability activates
   AttackSource	Weapon	Use weapon trace sockets for hit detection. Set to Unarmed for fist-based attacks.
   WeaponHand	MainHand	Use the main hand weapon's trace sockets
   bUseAttackChain	true	Enable the 3-hit chain system
   bLoopAttackChain	false	Do not loop back to Attack_01 after Attack_03 — end the chain
   ChainWindowDuration	0.0	We're using AnimNotifyState for window control, so set this to 0 to disable timer-based window
   ChainComboTimeout	1.5	If no next input arrives within 1.5 seconds after chain ends, reset the chain
   AttackChainSections	Add 3 entries	See below for each section
   DamageEffect	GE_WC_Combat_MeleeDamage	The damage GE to apply on hit
   BaseDamageValue	25.0	The SetByCaller Data.Damage value passed to the GE

   AttackChainSections — add 3 rows:

   SectionName	DamageMultiplier	AttackSource	WeaponHand	SectionStartOffset
   Attack_01	1.0	Weapon	MainHand	0.0
   Attack_02	1.15	Weapon	MainHand	0.05
   Attack_03	1.8	Weapon	MainHand	0.0

   SectionStartOffset on Attack_02 (0.05 = 50ms) skips the windup when chaining INTO this section mid-combo for snappier feel. Attack_03 is the finisher — no skip needed since players have had time to commit.

5. Configure Trace Settings in Project Settings

   Project Settings → Dynamic RPG Worlds → Combat:

   • TraceMode: MultiPointSweep — traces between previous and current socket positions every physics tick during the trace window. Best for fast swings.
   • TraceRadius: 15.0cm
   • TraceChannel: ECC_Pawn (or create a custom "WeaponTrace" channel in Project Settings → Collision)
   • bDebugTraces: true for now — disable before shipping

6. Grant the Ability to the Character

   Choose one of two methods:

   Method A — Via Weapon Equipment (Recommended): In your sword item's WCFragment_Equippable, add the ability tag to GrantedAbilities. The ability is automatically granted when the sword is equipped and revoked when unequipped.

   Method B — Via StartingAbilitiesData (Always Active): Create Data Asset → WCStartingAbilitiesData. Add WC.Ability.Combat.SwordSlash to the abilities list. On your character's WCGASAttributeInitializer component, set this asset as StartingAbilities. The ability is granted at BeginPlay.

7. Wire Input to the Ability

   If using a combat style (recommended), the style's CombatActionAbilities maps WC.Input.Action.Attack.Light → WC.Ability.Combat.SwordSlash. The WCInputHandler_CombatAbility with ActionSlotTag = WC.Input.Action.Attack.Light then resolves the ability from the active style and activates it.

   If NOT using a combat style, on the WCInputHandler_CombatAbility, set OnPressAbilityTag directly to WC.Ability.Combat.SwordSlash.

8. Test With AWCDummy

   Place an AWCDummy actor in your level. Press Play. Equip your sword. Walk up to the dummy. Press Attack. You should see:

   • The attack montage plays (Attack_01 section)
   • Red debug spheres appear along the blade during the trace window (if bDebugTraces is on)
   • The Output Log shows: [WCMeleeTrace] Hit: AWCDummy | Damage: 25.0 | Surface: Physical
   • Press Attack again quickly (during chain window) — the montage jumps to Attack_02
   • Press again — Attack_03 fires (with 1.8× damage multiplier)

   If nothing happens: verify the ability was granted (showdebug abilitysystem should list it), and confirm the melee trace notify exists in the montage.

Walkthrough: Your First Ranged Weapon (Complete)

End-to-end setup of a bow with arrow ammo, aim-down-sights, and reload mechanics.

1. Create the Arrow Ammo Item Definition

   Data Asset → WCItemDefinition. Name: DA_WC_Item_Arrow_Steel. Add these fragments:

   • WCFragment_Stackable: MaxStackCount = 99
   • WCFragment_Rarity: RarityTag = WC.Item.Rarity.Common
   • WCFragment_Ammunition:
     • AmmoTypeTag: WC.Combat.Ammo.Type.Arrow
     • BonusDamage: 0 (base arrows add no bonus)
     • ProjectileClass: AWCProjectileWorldItem (or your custom projectile)
     • RecoveryChance: 0.5 — 50% chance to recover the arrow after it lands

2. Create the Bow Item Definition

   Data Asset → WCItemDefinition. Name: DA_WC_Item_Bow_Wood. Add fragments:

   • WCFragment_Equippable: Slot = WC.Item.Slot.MainHand, Handedness = TwoHanded
   • WCFragment_RangedWeaponData:
     • RangedHitMethod: Projectile
     • FireMode: Single (one shot per press — required for attack chains with bows)
     • AmmoTypeTag: WC.Combat.Ammo.Type.Arrow — matches the arrow's AmmoTypeTag
     • AmmoConsumption: DirectPerShot — consumes one arrow from inventory per shot
     • AmmoLocation: Inventory — draws from the player's main inventory
     • ProjectileSpeed: 3000.0 cm/s
     • ProjectileGravityScale: 0.3 (slight arc for arrows)
     • DamageFalloffCurve: Optional curve asset — damage at full range
   • WCFragment_WeaponAccuracy: BaseSpread = 1.0, SpreadPerShot = 2.0, DecayRate = 8.0 (spread recovers quickly for bows)
   • WCFragment_EquipmentVisual: Assign bow mesh, attach socket, holster socket
   • WCFragment_CrosshairData: Assign a crosshair data asset suited for bows (dot-only, no spread arms)
   • WCFragment_CombatActions: Map WC.Input.Action.Attack.Light → WC.Ability.Combat.BowShot

3. Create the Bow Shot Ability Definition

   Data Asset → WCAbilityDefinition. Name: DA_WC_Ability_BowShot. Set AbilityTag = WC.Ability.Combat.BowShot, AbilityClass = WCGameplayAbility_Combat, NetExecutionPolicy = LocalPredicted.

   Add WCAbilityFragment_RangedCombat:

   Property	Value
   AttackMontage	Your bow shoot montage
   AttackSource	Weapon
   WeaponHand	MainHand
   RangedHitMethod	Projectile
   FireMode	Single
   BaseDamageValue	40.0
   DamageEffect	GE_WC_Combat_RangedDamage

   In the montage, place WCAnimNotify_ProjectileRelease at the frame where the arrow leaves the bow (when the hand releases). This is what actually fires the projectile.

4. Add Aim-Down-Sights (Optional)

   Create Data Asset → WCAbilityDefinition named DA_WC_Ability_BowAim. Add WCAbilityFragment_Aim:

   • AimBehavior: HoldToAim — hold the aim input, release to return to normal
   • AimRotationMode: OrientToCamera — character rotates to face camera direction while aiming
   • FOVMultiplier: 0.65 — reduces FOV to 65% for zoom effect
   • MovementSpeedMultiplier: 0.5 — slow movement while aiming

   Add this ability to the bow's WCFragment_Equippable → GrantedAbilities. Wire IA_WC_HeavyAttack to an WCInputHandler_CombatAbility with ActionSlotTag = WC.Input.Action.Aim.

5. Add Charge Attack for Bow (Optional)

   Add WCAbilityFragment_ChargeAttack to the BowShot ability definition:

   • ChargeTime: 1.5 seconds (time to reach full charge)
   • MinChargeRatio: 0.3 — must charge at least 30% before a valid release
   • ChargeDamageCurve: Create a float curve: at ratio 0.0 → multiplier 0.5, at ratio 1.0 → multiplier 2.0
   • ChargeSpeedCurve: Create a float curve for projectile speed scaling

   In the bow draw montage, place WCAnimNotify_ChargeStart at the frame when the bowstring is drawn. Charge tracking begins at this frame.

6. Test the Bow

   Equip the bow. The character should wield it (if you set up a WieldAbility). Press Attack — the draw-and-shoot montage plays, a projectile spawns at the muzzle, and it arcs toward where you're aiming. Check Output Log for: [WCRangedCombat] Projectile fired | Velocity: 3000 | Gravity: 0.3. If the projectile doesn't spawn, verify the WCAnimNotify_ProjectileRelease exists in the montage at the correct frame.

Walkthrough: Setting Up a Tree-Based Combo

Tree combos detect multi-input sequences (like quarter-circle combos in fighting games) and fire special abilities when the full sequence is entered.

1. Understand the Combo System

   The tree works like this: each node in the tree has incoming input conditions and an ability to fire. The player starts at the root and navigates deeper with each input. When a terminal node (no outgoing branches) is reached, the combo completes.

   Two modes:

   • FightingCombo: Only the final node fires an ability. The sequence is a "password" for a powerful move.
   • ComplexCombo: Every node fires its own ability. Each step triggers something (action RPG style).

2. Create the WCComboDefinition Asset

   Right-click → Miscellaneous → Data Asset → WCComboDefinition. Name it DA_WC_Combo_SpinningStrike.

3. Configure the Combo Identity

   • ComboTag: WC.Combat.Combo.SpinningStrike
   • ComboMode: FightingCombo — only the finisher fires
   • DefaultMaxStepInterval: 0.5 — player has 0.5 seconds between inputs by default
   • MaxTotalDuration: 3.0 — combo resets if not completed within 3 seconds total
   • Priority: 100 — higher priority combos are checked first
   • RequiredTags: Empty (available in any state)
   • BlockedTags: WC.State.Gameplay.Dead
   • CompletionAbilityTag: WC.Ability.Combat.SpinningStrike — ability that fires when the combo completes

4. Define the Combo Tree Nodes

   Our combo is: Light → Light → Heavy (three inputs). Add nodes to the Nodes array:

   Index	NodeName	AbilityTag	MaxTimeToReach	Notes
   0	"First Light"	Empty (FightingCombo — no intermediate ability)	0 (use default)	Reached after first Light input
   1	"Second Light"	Empty	0	Reached after second Light input
   2	"Spinning Strike Finisher"	WC.Ability.Combat.SpinningStrike	0	Terminal node — fires the finisher ability

5. Define the Root Transitions and Node Transitions

   In RootTransitions, add one entry:

   • InputTag: WC.Input.Action.Attack.Light
   • NextNodeIndex: 0

   On Node 0, in its Transitions array, add:

   • InputTag: WC.Input.Action.Attack.Light → NextNodeIndex: 1

   On Node 1, in its Transitions array, add:

   • InputTag: WC.Input.Action.Attack.Heavy → NextNodeIndex: 2

   Node 2 has no transitions — it's a terminal node, so reaching it completes the combo.

6. Add WCInputHandler_ComboInput to Your InputSetupData

   Open DA_WC_Input_Default. In Handlers, add WCInputHandler_ComboInput:

   • Priority: 100 (above normal, same as combat)
   • ComboDefinitions: Add DA_WC_Combo_SpinningStrike
   • FallbackAbilityTag: WC.Ability.Combat.SwordSlash — fires if no combo matches the input
   • bRouteToActiveAbilityOnNoMatch: true — routes to the active ability for attack chain advancement when no combo matches
   • InputAction: IA_WC_Attack (the handler listens to this action for combo inputs)

7. Create the Spinning Strike Ability

   Create DA_WC_Ability_SpinningStrike (WCAbilityDefinition). Add WCAbilityFragment_MeleeCombat with a special spinning montage and higher damage values. Grant this ability via WCStartingAbilitiesData or the equipped weapon.

8. Test the Combo

   Press Play. Press Light → Light → Heavy within 0.5 seconds between each input. You should see the Spinning Strike ability activate on the third input. Try pressing Light → Light → Light (wrong third input) — the combo should drop and fall back to the normal slash. Enable bDebugInputBuffer in Project Settings to see the combo tree navigation in the Output Log.

Walkthrough: Building a Loot Table

1. Create Item Definition Assets First

   Loot tables reference item definitions. Make sure you have at least 3–5 item definitions created (swords, potions, gold coins, etc.) following the item creation steps in the WCInventory module section.

2. Create the WCLootTableDefinition Asset

   Right-click → Miscellaneous → Data Asset → WCLootTableDefinition. Name it DA_WC_Loot_BanditChest.

3. Configure the Loot Table Properties

   • MinDrops: 2 — minimum number of items guaranteed to drop
   • MaxDrops: 4 — maximum number of items (randomized between min and max)
   • bGuaranteeMinDrops: true — always generate at least MinDrops even if RNG is unlucky

4. Add Loot Entries

   In the Entries array, click + for each possible drop. Each entry has:

   Property	Description	Example: Gold Coins
   EntryType	Item, NestedTable, or Nothing	Item
   ItemDefinition	The item to drop (only for Item type)	DA_WC_Item_GoldCoin
   Weight	Relative probability (higher = more common). Not a percentage — it's relative to the sum of all weights.	100 (very common)
   MinQuantity	Minimum stack size for this drop	5
   MaxQuantity	Maximum stack size for this drop	25
   bAlwaysDrop	This entry always drops regardless of roll (guaranteed drop)	false
   RequiredContextTags	FWCLootContext must have these tags for this entry to be eligible	Empty (always eligible)

   Add entries for: Gold Coins (weight 100, qty 5–25), Iron Sword (weight 30, qty 1), Health Potion (weight 50, qty 1–2), Rare Sword (weight 5, qty 1).

5. Add a Nested Table (Optional)

   For more variety, add an entry with EntryType = NestedTable and reference another loot table. When the RNG selects this entry, it rolls the nested table to determine the actual drop. Useful for: "10% chance to roll the 'rare weapons' table".

6. Call GenerateLoot from Blueprint

   On your chest actor's OnInteractionCompleted event:

   1. Get the WCInventoryLibrary node Generate Loot
   2. Connect your DA_WC_Loot_BanditChest as the Loot Table input
   3. Create a FWCLootContext struct: set CharacterLevel (from interactor), LuckFactor (from character's Luck attribute), ContextTags (optional filter tags)
   4. The node returns an array of FWCLootEntry (item definition + quantity)

7. Spawn World Items from Loot Results

   For each entry in the loot array, you have two choices:

   • Give to Player Directly: Call WCInventoryLibrary::AddItemToInventory(Interactor, LootEntry.ItemDef, LootEntry.Quantity)
   • Spawn as World Item: Call SpawnActor → AWCStandardWorldItem near the chest location, then call WorldItem::Initialize(LootEntry.ItemDef, LootEntry.Quantity)

   A common pattern: give small items (coins, potions) directly to inventory, and spawn world items for weapons and armor so the player can choose what to pick up.

Walkthrough: Crafting System — Recipe to Workbench

1. Create Ingredient Item Definitions

   Craft inputs are item definitions. Create simpler items for ingredients: DA_WC_Item_IronIngot, DA_WC_Item_WoodPlank. These only need minimal fragments: WCFragment_Stackable and WCFragment_Rarity.

2. Create the Recipe Category

   Data Asset → WCRecipeCategoryDefinition. Name: DA_WC_Recipe_Category_Blacksmithing.

   • DisplayName: "Blacksmithing"
   • Icon: Anvil icon texture
   • CategoryTag: WC.Crafting.Category.Blacksmithing

3. Create the Recipe Definition

   Data Asset → WCRecipeDefinition. Name: DA_WC_Recipe_IronSword.

   Property	Value
   RecipeName	"Iron Sword"
   Category	DA_WC_Recipe_Category_Blacksmithing
   RequiredStationTag	WC.Crafting.Station.Forge
   CraftingTime	3.0 seconds
   bRequiresCatalyst	false (no catalyst needed for basic recipe)

   In Inputs, add:

   • Entry 1: DA_WC_Item_IronIngot, Quantity: 3
   • Entry 2: DA_WC_Item_WoodPlank, Quantity: 1

   In Outputs, add:

   • Entry 1: DA_WC_Item_IronSword, Quantity: 1

4. Create the Crafting Station World Actor

   Create or open your Forge Blueprint (e.g., BP_WC_Forge). Add two components:

   • WCInteractableComponent: Type = Ability, InteractionText = "Craft", InteractionAbilityTag = WC.Ability.Interaction.OpenForge
   • WCCraftingStationComponent:
     • StationTypeTag: WC.Crafting.Station.Forge — this must match the RequiredStationTag in your recipes
     • AvailableRecipes: Add DA_WC_Recipe_IronSword (and any other recipes this station supports)

5. Open the Crafting UI on Interaction

   Create an ability DA_WC_Ability_OpenForge. Add a Blueprint ability fragment that calls WCUIManagerSubsystem::PushWidget(CraftingWidgetClass, GameMenuLayer) passing your WBP_WC_Crafting widget. The widget's view model (WCCraftingVM) auto-binds to the nearby crafting station when pushed.

6. Verify the Crafting Flow

   Press Play. Add 3 Iron Ingots and 1 Wood Plank to your inventory (use debug console). Walk to the Forge. Interact. The crafting UI should open showing the Iron Sword recipe. The ingredients should be highlighted as "available". Click Craft. After 3 seconds, the Iron Sword should appear in your inventory and the ingredients removed.

Walkthrough: Heritage — Setting Up Race and Class

1. Create a Race Data Asset

   Data Asset → WCGASRaceData. Name: DA_WC_Heritage_Race_Human.

   Property	Value
   RaceName	"Human"
   RaceTag	WC.Heritage.Race.Human
   Description	"Adaptable and resourceful."
   Icon	Human portrait texture
   RacialTags	Tags granted at character creation: WC.Heritage.Trait.Adaptive
   StartingAbilities	Optional — abilities every Human starts with
   AttributeModifiers	Flat bonuses: Strength +2, Agility +2, Intelligence +1
   ValidClasses	Empty = all classes allowed. Add class tags to restrict (e.g., Elves can't be Warriors).

2. Create a Class Data Asset

   Data Asset → WCGASClassData. Name: DA_WC_Heritage_Class_Warrior.

   • ClassName: "Warrior"
   • ClassTag: WC.Heritage.Class.Warrior
   • StartingAbilities: Melee combat ability tags specific to warriors
   • AttributeModifiers: Strength +5, Constitution +3 — applies on top of racial bonuses
   • ClassTraits: Tags that define class identity: WC.Heritage.Trait.MeleeSpecialist

3. Create a Subrace (Optional)

   Data Asset → WCGASSubraceData. For example, DA_WC_Heritage_Subrace_HighlanderHuman. A subrace modifies the parent race with additional attributes and traits. Assign to WCGASRaceData → Subraces array.

4. Apply Heritage at Character Initialization

   In your character Blueprint's BeginPlay (or a Character Creation system):

   1. Get the WCGASHeritageSubsystem: GetGameInstance → GetSubsystem (WCGASHeritageSubsystem)
   2. Call ApplyHeritage(TargetActor, RaceData, ClassData, SubraceData)
   3. This applies all attribute modifiers, grants starting abilities, and adds all heritage tags to the actor's ASC

5. Verify Heritage Application

   Press Play. Use showdebug abilitysystem. Under Gameplay Tags you should see the racial and class tags (WC.Heritage.Race.Human, WC.Heritage.Class.Warrior, etc.). Under Attributes, verify the starting attribute values include the racial and class bonuses on top of the base values.

Walkthrough: Skill Tree — From Zero to Unlockable Nodes

1. Design Your Skill Tree Structure

   Before creating assets, sketch your tree on paper. Decide: How many tiers? Which nodes are prerequisites for which? What abilities does each node grant? Common structure: Tier 1 has 3 nodes (starter), Tier 2 has 6 nodes (intermediate), Tier 3 has 3 powerful nodes (advanced).

2. Create the WCGASSkillTreeData Asset

   Data Asset → WCGASSkillTreeData. Name: DA_WC_SkillTree_Warrior.

   • TreeName: "Warrior Skills"
   • TreeTag: WC.SkillTree.Warrior
   • MaxTier: 3

3. Add Skill Nodes

   In the Nodes array, add one entry per skill. Each node:

   Property	Description	Example Node
   NodeName	Display name	"Power Strike"
   NodeTag	Unique identifier for this node	WC.SkillTree.Warrior.PowerStrike
   Tier	Which tier (1 = starter)	1
   PointCost	Skill points to unlock	1
   Prerequisites	Array of node tags that must be unlocked first	Empty (Tier 1 node, no prerequisite)
   AbilityToGrant	Ability tag granted when this node is unlocked	WC.Ability.Combat.PowerStrike
   EffectToApply	Optional permanent GE applied on unlock (e.g., +10 max health permanently)	—
   Description	Tooltip shown in UI	"A powerful overhead strike dealing 200% damage."
   Icon	Node icon texture	Sword icon

4. Unlock a Node from Blueprint

   When the player clicks a node in the skill tree UI:

   1. Get the WCGASAllySubsystem or directly call the unlocking function
   2. Call UnlockSkillNode(Actor, SkillTreeData, NodeTag)
   3. The system validates: are prerequisites met? Does the player have enough skill points? If valid, it grants the ability, applies any effects, and deducts skill points.
   4. Bind to OnSkillNodeUnlocked delegate to update the UI

5. Show Unlock State in UI

   In your skill tree widget Blueprint:

   • For each node button, call IsSkillNodeUnlocked(Actor, NodeTag) → set button appearance (unlocked = bright/filled, locked = dark/grayed)
   • Call CanUnlockSkillNode(Actor, SkillTreeData, NodeTag) → if prerequisites are met and the player has points, highlight the button as "available to unlock"
   • Show GetSkillPoints(Actor) as the available points counter

6. Grant Skill Points on Level Up

   Bind to the WCGASLevelingSubsystem::OnLevelUp delegate. On each level-up event, call AddSkillPoints(Actor, Amount) (typically 1–3 per level, depending on your design).

Walkthrough: Dynamic Society — Calendar and Factions

1. Configure the Calendar System

   In Project Settings → Dynamic RPG Worlds → Dynamic Society → Calendar:

   • DayNames: Array of strings for your world's days (e.g., ["Solday", "Moonday", "Fireday", "Waterday", "Earthday", "Windday", "Starday"])
   • MonthNames: Array of your world's months with day counts per month
   • SecondsPerGameHour: How many real seconds = 1 in-game hour. 60 = 1 minute of real time per game hour (24 min for a full day). 6 = very fast days.
   • StartingHour: What time the game begins (e.g., 8 = 8 AM)
   • StartingDay, Month, Year: Your world's starting date

2. Access the Calendar in Blueprint

   The calendar is a Game Instance Subsystem (not a World Subsystem):

   // Blueprint: Get Game Instance → Get Subsystem (class = CalendarSubsystem)
   CalendarSubsystem → GetCurrentHour()   // Returns 0-23
   CalendarSubsystem → GetCurrentDay()    // Returns day of week
   CalendarSubsystem → GetCurrentMonth()  // Returns month index
   CalendarSubsystem → GetTimePeriod()    // Returns enum: Morning/Day/Evening/Night

3. Bind to Time Events

   In your Level Blueprint or a persistent manager actor, bind to calendar events:

   • OnTimePeriodChanged: Fires when Morning/Day/Evening/Night transitions. Use to switch ambient audio, NPC behaviors, lighting.
   • OnNewDay: Fires at midnight. Use for daily resets, shop restocks, schedule changes.
   • OnSeasonChanged: Fires when the season changes. Use for weather changes, seasonal events.

4. Create Faction Data Assets

   Data Asset → WCFactionData (or equivalent in WCDynamicSociety). Create one per faction in your world:

   • FactionName: "The Merchants Guild"
   • FactionTag: WC.Society.Faction.MerchantsGuild
   • InitialReputation: 0 (neutral)
   • ReputationTiers: Define thresholds for ranks: -100 = Enemy, -50 = Hostile, 0 = Neutral, 50 = Friendly, 100 = Honored, 200 = Exalted
   • FactionRelationships: Faction-to-faction relationships (e.g., MerchantsGuild dislikes Thieves, FactionRelationValue = -50)

5. Add a Social Component to NPCs

   On your NPC Blueprint, add the WCDynamicSociety social component (e.g., WCSocialComponent or WCNPCDataComponent). Configure:

   • FactionMembership: Which factions this NPC belongs to
   • PersonalityTraits: Tags describing personality (aggressive, cowardly, friendly)
   • ScheduleData: Optional reference to a schedule defining the NPC's daily routine

6. Modify Player Reputation

   When the player completes quests, makes purchases, or commits crimes:

   // Blueprint: Get Dynamic Society Subsystem → Modify Reputation
   DynamicSocietySubsystem → ModifyPlayerReputation(
       PlayerActor,
       FactionTag,
       Amount,   // Positive = gain, negative = lose
       bPropagate  // Propagate to allied/enemy factions automatically
   )

7. Use Async Actions for Waiting

   In Blueprints that need to wait for a society event without blocking:

   • Use WaitForTimePeriod (Async) — fires when the specified time period (Night, Morning, etc.) begins. Useful for quests that require "come back at night".
   • Use WaitForReputationThreshold (Async) — fires when player reputation with a faction crosses a threshold. Useful for unlocking quests dynamically.

End-to-End Test Checklist

Use this checklist to verify your entire WC RPG World framework is assembled correctly. Tick each item after confirming it works in Play mode.

• Installation: Project Settings shows "Dynamic RPG Worlds" category with GAS Core, Input, Interaction, Inventory, Combat, UI, and Audio sub-sections.
• Framework Classes: Game Mode, Player Controller, Player State, HUD, and Game State are all set to WC Blueprint subclasses in Maps & Modes.
• Character: Player character spawns correctly from Player Start. Character has correct mesh and capsule size.
• Movement: WASD moves the character. Character movement feels responsive with no jitter.
• Look: Mouse controls camera rotation. No issues with axis inversion.
• Jump: Space bar makes character jump. Jump height is appropriate. Landing is smooth.
• Attributes: showdebug abilitysystem shows all registered attributes (Health, Stamina, etc.) with correct base values.
• Attribute Regen: Stamina (or whichever attribute has regen configured) refills over time after depletion.
• Interaction Detection: Walk up to an interactable actor — the prompt widget appears at the correct screen position.
• Interaction Trigger: Press Interact key — the OnInteractionCompleted event fires on the interactable actor.
• Inventory — Item Creation: A weapon item definition can be given to the player via Blueprint code and appears in the inventory component.
• Equipment — Equip: Equipping a weapon attaches the mesh to the correct character socket and grants any GAS abilities/effects listed on WCFragment_Equippable.
• Equipment — Unequip: Unequipping the weapon removes the mesh and revokes the granted abilities/effects.
• Combat Style: Equipping the correct weapon combination activates the combat style. The style's abilities appear in showdebug abilitysystem.
• Melee Attack: Press Attack — the attack montage plays and the melee trace runs during the correct frames (visible with bDebugTraces).
• Hit Detection: Melee attack on AWCDummy registers a hit. Output Log shows "Hit detected" with correct actor name.
• Damage Application: AWCDummy's health attribute decreases after being hit. Output Log shows damage value.
• Attack Chain: Pressing Attack twice within the chain window transitions to the second montage section.
• HUD Visible: HUD widget is visible on screen during gameplay. No null reference errors in Output Log related to HUD.
• Crosshair: Crosshair appears when ADS ability is activated (Aiming tag added to ASC). Disappears when ADS ends.
• Hit Marker: Hitting AWCDummy causes a hit marker flash on the crosshair.
• Music: Background music plays on game start. Music transitions when combat begins and returns to exploration music when combat ends.
• Ambient Audio: Entering an AWCAmbientZoneVolume causes ambient sounds to fade in. Exiting fades them out.
• Multiplayer — Replication: Run with 2 players. Character movement of Player 2 is visible on Player 1's screen and vice versa.
• Multiplayer — Damage: Player 1 hits AWCDummy. The damage is visible to both Player 1 and Player 2 (health depletes on both screens).

Deep Dive: GAS and Attributes

How the Attribute Pool Works

At startup, WCGASAttributeRegistry loads all WCGASAttributeDefinition assets registered in Project Settings. Each definition is assigned a numbered pool slot (Health → slot 0, Stamina → slot 1, etc.). When an actor is initialized, its WCGASAttributeInitializer creates a WCGASAttributePool AttributeSet containing all 150 pre-generated attributes and grants it to the ASC — giving that actor all attributes, initialized from BaseValue. Unused slots cost nothing in gameplay.

Reading and Modifying Attributes

// C++: Read attribute value
float Health = WCGASAttributePoolHelper::GetAttributeValue(ASC, WCTags::Attribute_Health);

// C++: Bind to value changes
WCGASAttributePoolHelper::BindValueChangedDelegate(ASC, WCTags::Attribute_Health, [](float OldVal, float NewVal){
    // React to health change
});

// Blueprint: Use the "Get Attribute Value" node from WCGASAttributePoolHelper
// Pass the ASC and the attribute tag, returns current value as float

Creating Gameplay Effects That Modify Attributes

To apply damage or healing via GAS effects:

1. Create a Blueprint subclass of UGameplayEffect
2. Set Duration Policy: Instant for one-time changes, Infinite for permanent buffs, HasDuration for timed effects
3. In Modifiers, add an entry for each attribute to modify. For damage: attribute = Health, Op = Add, Magnitude = SetByCaller with tag Data.Damage
4. Apply the effect via: ASC → ApplyGameplayEffectToTarget(GEClass, TargetASC, Level)

Deep Dive: Ability Fragment System

How Fragments Work

A WCAbilityDefinition holds an array of WCAbilityFragment objects. Each fragment can have RequiredTags/BlockedTags — conditions that gate whether the fragment executes for a given actor. When an ability activates, each fragment's lifecycle hooks fire in array order. Fragments are shared objects (not per-actor), so mutable state must be stored via the ability instance's fragment state storage.

Fragment Lifecycle Hooks

Creating a Custom Blueprint Fragment

1. Create the Fragment Blueprint

   Right-click → Blueprint Class → WCAbilityFragment. Name it following the pattern: ABF_WC_[Name] (e.g., ABF_WC_PlaySoundOnActivate). Store in Content/WC/GAS/Fragments/.

2. Override OnAbilityActivated

   In the Event Graph, right-click → Add Event → Event On Ability Activated. The event has an Ability output parameter (the WCGameplayAbility instance). Use this to access the owning actor, the ASC, montage playback, etc.

   Example — play a sound on activate: drag from Ability → Get Avatar Actor → Spawn Sound Attached with your sound asset.

3. Set Activation Conditions (Optional)

   In the Blueprint's default values (open the Blueprint, click the CDO in the Details panel), set Required Tags and Blocked Tags. Example: RequiredTags = WC.Combat.State.Armed.Ranged means this fragment only executes when a ranged weapon is drawn.

4. Add to an Ability Definition

   Open any WCAbilityDefinition asset. In Fragments, click + and select your new fragment class from the dropdown. Configure its properties in the expanded inline editor.

Fragment Runtime State (C++ Only)

For fragments that need to store per-activation data, use the ability's fragment state map:

// Define a state struct (in your Fragment's header)
USTRUCT() struct FMyFragmentState { GENERATED_BODY()
    float ElapsedTime = 0.f;
    bool bIsActive = false;
};

// Read/write in fragment hooks:
FMyFragmentState& State = Ability->GetOrCreateFragmentState<FMyFragmentState>();
State.ElapsedTime += DeltaTime;

// Check if state exists:
if (Ability->HasFragmentState<FMyFragmentState>()) { ... }

// Clear state (e.g., on ability end):
Ability->ClearFragmentState<FMyFragmentState>();

Deep Dive: Item Fragment System

Creating a Custom Item Fragment

1. Create a C++ Subclass of UWCItemFragment

   UCLASS(DefaultToInstanced, EditInlineNew, BlueprintType)
   class UMyMagicFragment : public UWCItemFragment
   {
       GENERATED_BODY()
   public:
       UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Magic")
       float MagicPower = 0.f;
   
       UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Magic")
       FGameplayTag MagicSchoolTag;
   };

   Add it to your module's Build.cs public includes. Compile.

2. Add to Item Definitions

   Open any WCItemDefinition. In Fragments, click + and select UMyMagicFragment. Set MagicPower and MagicSchoolTag. Save.

3. Access at Runtime (C++)

   // From item instance:
   if (UMyMagicFragment* MagicFrag = ItemInstance->GetItemDefinition()->FindFragment<UMyMagicFragment>())
   {
       float Power = MagicFrag->MagicPower;
   }

4. Access at Runtime (Blueprint)

   In Blueprint, call WCInventoryLibrary → FindFragmentOfClass(ItemInstance, FragmentClass). Cast the result to your fragment class and access the properties.

Class Reference

DynamicRPGWorlds Module

WCGASCore Module

WCCombat Module

Tag Reference

Blueprint API Quick Reference

WCInventoryLibrary

WCInteractionLibrary

WCCoreLibrary

WCAudioLibrary

Multiplayer Considerations

Key Multiplayer Rules

• All gameplay-critical actions (pick up, equip, use ability) must be validated on the server
• Attack chains use PlayMontage (GAS-replicated), never JumpToSection (local-only)
• Use Client RPCs only for visual/audio feedback, never for authoritative state changes
• Set NetExecutionPolicy = LocalPredicted on player-facing combat abilities for responsiveness

Troubleshooting

Build Errors

Runtime Issues

Debug Tools

• Console command showdebug abilitysystem: Shows all attributes, active effects, and granted abilities on the possessed pawn
• AWCDummy: Drop in any level — logs all hits, effects, and attribute changes to Output Log
• WCAbilityFragment_Debug: Add to any ability definition to get lifecycle hook logging to Output Log and screen
• bDebugTraces (Project Settings → Combat): Draws melee trace spheres in the world
• bDebugInputBuffer (Project Settings → Input): Shows buffered input overlay on screen
• bEnableDebugVisualization (Project Settings → Interaction): Draws interaction detection volumes
• Output Log filter: Filter by "WCInventory", "WCCombat", "WCInteraction" etc. to see only specific module logs

Development Roadmap

The table below shows the current module status. For the full interactive roadmap — including phase breakdowns, task tracking, and detailed release planning — open the owner reference dashboard: