GAS Ally

🧬 What is GAS Ally?

GAS Ally (WCGASAlly) is the flagship RPG-depth module of the Wonderscape Creations plugin framework. It sits on top of Unreal Engine's Gameplay Ability System (GAS) and the WCGASCore attribute layer to deliver a complete, production-ready RPG character simulation system.

Where vanilla GAS gives you raw tools — Attributes, Abilities, and Effects — GAS Ally gives you fully designed RPG systems built on those tools: dynamic leveling, multi-layer heritage (race/class/subclass), skill trees, status effect evolution chains, multi-layer resistance, squad AI, boss phases, world context reactions, and much more.

How GAS Ally Relates to Other Modules

✅ Prerequisites

Before diving into GAS Ally, make sure your environment and knowledge base are properly prepared.

Engine & Tools

Required Engine Plugins (Auto-Enabled)

WCGASAlly's .uplugin automatically enables these. You do not need to enable them manually:

Knowledge Prerequisites

GAS Ally is complex. The following knowledge will dramatically reduce your ramp-up time:

🔧 Installation

GAS Ally ships as part of the Dynamic RPG Worlds plugin package. You install the whole plugin, then use whichever modules you need.

1. Convert to C++ Project (if needed)

   Blueprint-only projects cannot compile the plugin. If your project has no Source/ folder:

   1. Open Unreal Editor
   2. Go to Tools → New C++ Class
   3. Choose any parent class (e.g., Actor) and click Create Class
   4. The editor will generate the Source/ folder and .sln file

2. Place the Plugin

   Copy the entire DynamicRPGWorlds folder into your project's Plugins/ directory. Create the directory if it doesn't exist:

   YourProject/
   ├── Content/
   ├── Source/
   └── Plugins/
       └── DynamicRPGWorlds/        ← the whole plugin folder goes here
           ├── DynamicRPGWorlds.uplugin
           ├── Source/
           │   ├── WCGASAlly/       ← GAS Ally runtime module
           │   └── WCGASAllyEditor/ ← GAS Ally editor module
           └── Documentation/

3. Enable in the Editor

   1. Open your project in Unreal Editor (it will offer to rebuild — click Yes)
   2. Go to Edit → Plugins
   3. Search for "Dynamic RPG Worlds"
   4. Toggle Enabled and click Restart Now

4. Rebuild Project Files

   Right-click your .uproject file in Windows Explorer and choose "Generate Visual Studio project files" so the new modules appear in your solution.

5. Compile

   Open the .sln in Visual Studio 2022. Select Development Editor | Win64 configuration and press Ctrl+Shift+B.

   ⚠️

   The first build compiles hundreds of files across all modules. Expect 5–15 minutes depending on your hardware. Subsequent builds are incremental and take seconds.

6. Verify the GAS Ally Module

   After the Editor launches, verify:

   • Edit → Project Settings → scroll to the "WC GAS Ally" section — you should see it
   • Right-click in the Content Browser → Miscellaneous → Data Asset — search for WCGASAlly to see all GAS Ally Data Asset types available
   • Check the Output Log for LogWCGASAlly category messages at startup

🚀 Quick Start Guide

Follow this guide to build a working GAS Ally character from scratch — with heritage, leveling, a skill tree, and a status effect — in under one hour.

Step 1 — Add GAS Ally Components to Your Character

Open your player character Blueprint (parent: WCPlayerCharacter or any AWCCharacterBase descendant). In the Components panel, add the following components if not already present:

Step 2 — Create a Heritage Set (Race + Class)

1. Create a Race Definition

   In Content Browser: Right-click → Miscellaneous → Data Asset → WCHeritage_RaceDefinition. Name it DA_WC_Race_Human. Configure:

   • Display Name: "Human"
   • Base Attribute Modifiers: add a modifier for Health.Max (+50), Stamina.Max (+25)
   • Racial Blessings: leave empty for now (covered in Advanced section)

2. Create a Class Definition

   Right-click → Data Asset → WCHeritage_ClassDefinition. Name it DA_WC_Class_Warrior. Configure:

   • Display Name: "Warrior"
   • Class Attribute Modifiers: PhysicalAttack (+20), Armor (+15)

3. Create a Heritage Set

   Right-click → Data Asset → WCHeritageSet. Name it DA_WC_Heritage_HumanWarrior.

   • Set Race to DA_WC_Race_Human
   • Set Class to DA_WC_Class_Warrior
   • Leave Subrace empty for now

4. Apply Heritage at BeginPlay

   On your character Blueprint's Event BeginPlay node, call the UWCHeritageComponent function: Apply Heritage Set, passing in DA_WC_Heritage_HumanWarrior.

Step 3 — Set Up Leveling

1. Create Leveling Rules

   Right-click → Data Asset → WCLevelingRules. Name it DA_WC_LevelingRules_Default.

   • Formula Type: choose Exponential for a classic RPG curve
   • Base XP: 100
   • Exponent: 1.5 (each level requires 1.5× more XP)
   • Max Level: 50
   • Level-Up Rewards: add a row for every level — e.g., at Level 2: Grant 2 Skill Points

2. Assign Rules to the Component

   On your character Blueprint, select the WCLevelingComponent. In the Details panel, set Leveling Rules to DA_WC_LevelingRules_Default.

3. Test Granting XP

   In the Blueprint, wire a test Input Action (e.g., press G) to call Grant XP on the WCLevelingComponent with an amount of 150. Watch for level-up notifications in the Output Log.

Step 4 — Build a Skill Tree

1. Create Skill Tree Data

   Right-click → Data Asset → WCSkillTreePreset. Name it DA_WC_SkillTree_WarriorBasic. Add nodes:

   • Node 0 — "Iron Skin": Cost 1 point, no prerequisites, grants +10 Armor via Gameplay Effect
   • Node 1 — "Battle Hardened": Cost 2 points, requires Node 0, grants +25 Health Max via Gameplay Effect

2. Assign the Preset

   On your character Blueprint, select the WCSkillTreeComponent. Set Skill Tree Preset to DA_WC_SkillTree_WarriorBasic.

3. Unlock a Node

   Call Try Unlock Node on the WCSkillTreeComponent, passing the Node ID and the character's ASC. The component checks prerequisites and skill point costs automatically.

Step 5 — Add a Status Effect (Burning → Scorched)

1. Create the "Burning" Status Effect Definition

   Right-click → Data Asset → WCStatusEffectDefinition. Name it DA_WC_Status_Burning.

   • Effect Tag: WC.Status.Burning
   • Stacking: Aggregate, Max Stacks: 5
   • Duration: 8 seconds
   • Tick Interval: 1 second
   • Tick GE: a Gameplay Effect that deals 5 fire damage per tick

2. Create the "Scorched" Status Effect

   Create a second WCStatusEffectDefinition named DA_WC_Status_Scorched with more severe fire damage (15 per tick) and 12 second duration.

3. Create an Evolution Rule

   Right-click → Data Asset → WCStatusEvolutionRule. Configure:

   • Source Effect: DA_WC_Status_Burning
   • Evolves To: DA_WC_Status_Scorched
   • Trigger: Stack Count ≥ 3

4. Apply the Status in Blueprint

   Call Apply Status Effect on the target character's WCStatusEffectComponent, passing DA_WC_Status_Burning. Each repeated call adds a stack. At 3 stacks, the evolution triggers automatically.

🏗️ Architecture Overview

GAS Ally is organized into interconnected systems, each with its own component, subsystem, data assets, and function library. Understanding this structure is essential before building anything complex.

System Organization

Data Flow: How a Character is Initialized

The Editor Module (WCGASAllyEditor)

The editor module provides quality-of-life tooling that is not present at runtime. It includes:

• Asset Factories — Right-click → Data Asset menus for all GAS Ally asset types
• Attribute Validator — Validates attribute definition assets at editor compile time
• Property Customizations — Custom Details panels for complex data structures (resistance tables, evolution chains)
• Gameplay Debug Category — Adds a WCGASAlly category to the Gameplay Debugger (` → 5) showing live attribute values, active status effects, and threat data

📊 Attribute System

GAS Ally uses the WCGASCore attribute pool as its foundation. Rather than hard-coding UAttributeSet subclasses with fixed properties (the vanilla GAS approach), WCGASCore provides a dynamic pool of 150 float attribute slots that are mapped at runtime to named definitions.

How Attributes Work in GAS Ally

1. You create a WCGASAttributeDefinition Data Asset for each attribute (Health, Mana, Stamina, PhysicalAttack, etc.).
2. You register each definition in Project Settings → WCGASCore → Attribute Definitions.
3. At runtime, the UWCGASAttributeInitializer component reads the registry and assigns each definition to a pool slot (up to 150).
4. Every GAS Ally system (damage calcs, regen, resistance, skill trees) references attributes by their Gameplay Tag name, not by C++ property pointers — so you never need to recompile to add a new attribute.

Attribute Definition Properties

The 12 Formula Types (Attribute Modifiers)

When other systems (Heritage, Skill Trees, Leveling rewards) apply modifications to attributes, they use one of 12 formula types:

🔩 Key Components

Every GAS Ally system is delivered as an Actor Component. You add them to any character (player or AI) and they auto-register with their corresponding subsystem.

Component Quick Reference

⚙️ Subsystems

Subsystems are long-lived game-wide or world-wide singletons that manage global state for each GAS Ally system. They are accessed via GetWorld()->GetSubsystem<U...Subsystem>() in C++ or via the Blueprint function libraries.

Listening to Subsystem Events

The UWCEventsSubsystem is the recommended way to react to GAS Ally events in Blueprint. All major events are broadcast as delegates:

// C++ — bind to the events subsystem
if (UWCEventsSubsystem* Events = GetWorld()->GetSubsystem<UWCEventsSubsystem>())
{
    Events->OnCharacterLevelUp.AddDynamic(this, &ThisClass::HandleLevelUp);
    Events->OnStatusEffectEvolved.AddDynamic(this, &ThisClass::HandleEvolution);
    Events->OnFeatEarned.AddDynamic(this, &ThisClass::HandleFeat);
}

⚙️ Settings Reference

GAS Ally settings live under Edit → Project Settings → WC GAS Ally via the UWCGASAllySettings class. All settings are loaded once at startup and cached.

🧬 Heritage System

The Heritage System defines a character's biological and vocational identity. A Heritage Set is composed of up to four layers:

Heritage Data Assets

WCHeritage_RaceDefinition

WCHeritage_ClassDefinition

WCHeritageSet

The Heritage Set is the top-level asset you apply to a character. It references all four layers and is the only asset the WCHeritageComponent needs:

// Apply a heritage set in Blueprint via the component function
UWCHeritageComponent* Heritage = Character->FindComponentByClass<UWCHeritageComponent>();
Heritage->ApplyHeritageSet(HumanWarriorHeritageSet);

Heritage Validation

The WCGASAllyEditor module validates Heritage assets at compile time. Common validation errors:

📈 Leveling System

The Leveling System provides a completely data-driven approach to character progression. XP formulas, thresholds, milestones, and rewards are all authored in Data Assets — no C++ required for most setups.

WCLevelingRules Data Asset

XP Formula Types

Level-Up Rewards

The LevelUpRewards TMap lets you specify exactly what happens at each level-up. Each FWCLevelReward struct contains:

• SkillPointsGranted — How many skill points are added to the Skill Tree pool
• AbilitiesToGrant — Array of ability classes to grant via the ASC
• GameplayEffectsToApply — GEs applied at level-up (stat boosts, permanent buffs)
• MilestoneTag — Optional tag broadcast on the events subsystem at this level

Using the Leveling Component

// Blueprint callable functions on UWCLevelingComponent:

// Grant XP (triggers level-up if threshold reached)
LevelingComp->GrantXP(500.0f);

// Get current level
int32 Level = LevelingComp->GetCurrentLevel();

// Get XP progress toward next level (0.0 - 1.0)
float Progress = LevelingComp->GetLevelProgress();

// Force set level (bypasses XP, used for save-game restore)
LevelingComp->SetLevel(10, /* bApplyRewards */ false);

🌳 Skill Trees

The Skill Tree system is a graph-based progression system where characters spend earned skill points to unlock nodes that permanently enhance their capabilities.

WCSkillTreePreset Data Asset

A Skill Tree Preset defines the entire tree for a character archetype. Properties:

Skill Tree Node Properties (FWCSkillTreeNode)

MMC-Based Bonuses

Skill tree nodes that grant attribute bonuses use the GAS Modifier Magnitude Calculation system. The recommended pattern is to create a Gameplay Effect with a Modifier that uses an MMC_WCSkillTree_* class — these are pre-built MMCs in the framework that evaluate bonuses based on how many nodes in a category are unlocked:

// Example: A node that grants +5 Strength per Warrior-category node unlocked
// GE Modifier: Attribute = WC.Attribute.Strength
// Magnitude Calculation: MMC_WCSkillTree_CategoryCount
// Coefficient: 5.0
// Category Tag: WC.SkillTree.Category.Warrior

Custom Unlock Requirements Advanced

For complex unlock conditions (e.g. "Unlock only if player has completed a quest tag"), create a C++ class inheriting UWCSkillTreeUnlockRequirement and override:

UCLASS()
class UMyCustomUnlock : public UWCSkillTreeUnlockRequirement
{
    GENERATED_BODY()
public:
    virtual bool CanUnlock(const UWCSkillTreeComponent* TreeComp,
                           const UAbilitySystemComponent* ASC,
                           const FWCSkillTreeNode& Node) const override
    {
        // Your custom logic here
        return ASC->HasMatchingGameplayTag(FGameplayTag::RequestGameplayTag("WC.Quest.Completed.HunterTrial"));
    }
};

🎓 Ability Curriculum

The Ability Curriculum is a guided learning system for abilities. Instead of abilities being granted automatically (as with Heritage or Leveling), the Curriculum lets designers define a catalog of learnable abilities with costs and prerequisites — and players actively choose what to learn.

WCAbilityCurriculumData

Curriculum Entry (FWCCurriculumEntry)

Learning an Ability in Blueprint

1. Check if Learnable

   Call CanLearnAbility(AbilityClass) on the UWCAbilityCurriculumComponent. Returns a struct with: bCanLearn, FailureReason (for UI feedback).

2. Spend Resources and Learn

   Call LearnAbility(AbilityClass) on the server. The component deducts costs, grants the ability via the ASC, and saves the learned state.

3. Listen for the Callback

   Bind to OnAbilityLearned delegate on the component or listen via the UWCEventsSubsystem.

📚 Ability Library

The Ability Library provides a hierarchical catalog system for organizing abilities — Books contain Pages, and Pages contain Ability Definitions. This gives designers a structured way to author and navigate large ability sets.

The Ability Library is primarily a data organization and query tool. You can ask it: "Give me all Fire magic abilities available to a Level 10 Mage" and it returns the filtered list. UI systems then present the results to the player.

// Blueprint API example:
// Get all abilities in a book that the character can use
TArray<FWCAbilityDefinition> Available = 
    UWCGASAbilityLibFuncLib::QueryAbilityBook(FireMagicBook, Character->GetASC());

🏆 Feats System

Feats are achievement-like milestones that characters earn through gameplay events. They are tracked by the UWCFeatComponent and trigger gameplay rewards when milestones are reached.

WCFeatPool

A collection of trackable feat counters. Each feat in the pool has:

WCFeatMilestone

Milestones define rewards at specific counter thresholds:

Auto-Tracking via Gameplay Tags

The most powerful feature of Feats: they can auto-increment using existing Gameplay Event Tags. If you set IncrementEvents to include WC.Event.EnemyKilled, then every time that tag is sent to the ASC (e.g. by a damage execution), the feat counter goes up — no extra Blueprint wiring needed.

// Send a feat increment event from C++ or Blueprint
FGameplayEventData Payload;
UAbilitySystemBlueprintLibrary::SendGameplayEventToActor(
    Character, 
    FGameplayTag::RequestGameplayTag("WC.Event.EnemyKilled"),
    Payload
);

💀 Status Effects

GAS Ally's Status Effect system extends standard Gameplay Effects with stacking logic, custom tick behavior, evolution chains, and synergy combos. It is one of the most powerful and configurable systems in the plugin.

WCStatusEffectDefinition

Stacking Policies

Applying and Removing Status Effects

// Blueprint callable via UWCStatusEffectComponent:

// Apply a status effect (adds a stack if already present)
StatusEffectComp->ApplyStatusEffect(DA_WC_Status_Burning, Instigator);

// Remove all stacks of a specific status
StatusEffectComp->RemoveStatusEffect(DA_WC_Status_Burning);

// Remove one stack
StatusEffectComp->RemoveStatusEffectStack(DA_WC_Status_Burning, 1);

// Check if a status is active
bool bIsBurning = StatusEffectComp->IsStatusEffectActive(FGameplayTag("WC.Status.Burning"));

🔥 Status Effect Evolution

Evolution allows a status effect to automatically transform into a more powerful variant when certain conditions are met. This enables deep combat interaction design — e.g., Wet + Lightning = Electrified, or 3× Burning → Scorched.

WCStatusEvolutionRule

Evolution Flow

⚡ Status Synergy

Synergy goes beyond evolution — it triggers effects when two or more different status effects are active simultaneously on the same target. This creates emergent elemental interaction systems.

WCStatusSynergyRule

Example: Wet + Burning = Explosion

// Synergy Rule Data Asset: DA_WC_Synergy_WetBurning
// RequiredStatusTags: [WC.Status.Wet, WC.Status.Burning]
// SynergyEffect: DA_GE_SteamExplosion (heavy AoE damage)
// NewStatusToApply: DA_WC_Status_Steamed (vision-impairing steam cloud)
// bConsumeInputEffects: true   (removes Wet and Burning)
// CooldownSeconds: 10.0

🛡️ Resistance System

GAS Ally provides four independent resistance layers, each implemented as a Gameplay Effect Component. They are evaluated in order during damage calculation and can be stacked, overridden, or diminished.

The Four Resistance Layers

Resistance Data Asset (WCResistanceData)

Damage Calculation Order

Per-Damage-Type vs. Global Resistance

You can register multiple WCResistanceData assets with different DamageTypeTag values on the same character. When damage comes in, the system queries:

1. Exact type match (e.g. WC.DamageType.Fire)
2. Parent tag match (e.g. WC.DamageType.Elemental if Fire has no specific entry)
3. Global fallback (WC.DamageType.Any)

All matching entries are combined — so a character can have base physical resistance AND bonus fire resistance from a Heritage effect simultaneously.

🚫 Immunity System

The Immunity GE Component (UWCImmunityGEComponent) is a Gameplay Effect Component that, when active on a character's ASC, blocks specific damage types or status effects entirely.

Creating an Immunity Effect

1. Create a Gameplay Effect

   Create a new Gameplay Effect of type Infinite (since immunity usually needs to stay active).

2. Add the Immunity Component

   In the GE's Gameplay Effect Components array, add WCImmunityGEComponent.

3. Configure Tags to Block

   In the component's properties:

   • DamageTypesToBlock: Tag container of damage types that are completely nullified
   • StatusEffectsToBlock: Tag container of status effect tags that cannot be applied
   • bBlockAll: Set true for complete damage immunity (boss phase invincibility, cutscene, etc.)

4. Apply the GE

   Apply this GE to the character's ASC like any Gameplay Effect. Remove it to end immunity.

💚 Regen & Degeneration

The Auto-Regen system ticks at a configurable interval and applies regeneration or degeneration to any attribute that has bSupportsRegen = true in its definition and a configured regen-rate attribute.

How Regen Works

1. The UWCRegenSubsystem ticks every RegenTickInterval seconds (default: 0.25s).
2. For each registered character, it queries all attributes with bSupportsRegen = true.
3. It reads the current value of the linked RegenRateTag attribute.
4. It applies a small GE that adds RegenRate × TickInterval to the attribute.
5. Degeneration works identically — a negative regen rate causes the attribute to decrease over time.

Regen MMCs

For more complex regen behavior (e.g. regen that scales with out-of-combat duration), GAS Ally provides pre-built MMCs:

Pausing and Resuming Regen

The UWCAutoRegenComponent exposes control functions for gameplay scenarios (stunned characters shouldn't regen mana, combat zones stop health regen, etc.):

// Pause all regen on this character
AutoRegenComp->PauseRegen();

// Resume with a multiplier (0.5 = half regen rate, useful for out-of-combat bonus)
AutoRegenComp->ResumeRegen(/* Multiplier */ 2.0f);

// Pause only specific attribute
AutoRegenComp->PauseAttributeRegen(FGameplayTag::RequestGameplayTag("WC.Attribute.Mana"));

⚔️ Damage & Healing Calculations

GAS Ally provides a rich set of Execution Calculations and helper libraries for all damage and healing processing.

Damage Execution Calculation

All combat damage flows through the GAS Execution Calculation system. GAS Ally's damage calc (UWCGASExecCalc_Damage) performs the following pipeline:

Damage Calculation Library (UWCDamageCalcLibrary)

Blueprint-callable helper functions for querying and manually computing damage values:

Healing Execution Calculation

Healing uses UWCGASExecCalc_Healing. It captures the healer's HealingPower attribute, applies any healing bonuses (buffs via GE), and clamps the result to the target's MaxHealth. Overheal (excess healing) routes to the Overflow System if configured.

🤖 AI Systems Overview

GAS Ally ships a complete AI combat framework that integrates tightly with GAS. The AI system is not just about movement — it is a full tactical simulation layer including threat management, squad coordination, and boss phase scripting.

AI Architecture Layers

The Combat AI Component

UWCCombatAIComponent is the hub that connects all AI systems. Add it to any AI character class:

🌳 Behavior Tree Nodes

GAS Ally provides a full library of custom Behavior Tree nodes in all three categories (Tasks, Decorators, Services) that understand the GAS Ally world.

Tasks

Decorators

Services

🗺️ EQS Integration

GAS Ally extends the Environment Query System so your AI can make spatial decisions that account for GAS-aware concepts like threat, cover, and ally grouping.

Custom EQS Contexts

Custom EQS Tests

🔄 StateTree Tasks & Conditions

GAS Ally provides StateTree integration for high-level AI state management. StateTree is ideal for modeling the AI's overarching behavioral mode (Patrol, Combat, Retreat, BossPhase1, BossPhase2, etc.) while Behavior Trees handle the moment-to-moment decision-making within each state.

StateTree Tasks (WCGASAlly)

StateTree Conditions (WCGASAlly)

👥 Squad System

The Squad System allows groups of AI characters to coordinate their behavior as a tactical unit. Squads share threat information, can issue commands to each other, and behave collectively in combat.

WCSquadData Asset

How Squads Work

1. AI characters register themselves with the UWCCombatAISubsystem on BeginPlay via their WCCombatAIComponent.
2. Members are grouped into squads based on their SquadData asset tag.
3. The first member to register becomes the Squad Leader.
4. When a squad member generates threat (by attacking, receiving damage, using abilities), a percentage is broadcast to all other members.
5. Squad commands (e.g. "FlankLeft", "FocusFire", "Retreat") are sent via BTTask_WC_CallSquadAction and received by all members listening via BTService_WC_MonitorSquad.

🎯 Threat System

The Threat System determines which target an AI focuses on at any given moment. It is more nuanced than simple distance-based targeting — it models an AI's awareness of who poses the greatest strategic threat.

WCThreatData Asset

Threat Modifiers from GAS Events

Threat is automatically generated when the threat system intercepts Gameplay Events sent to the AI's ASC:

👑 Boss Phase System

The Boss Phase System allows AI bosses to dramatically change their behavior, abilities, and stats at specific health thresholds — without any special-casing in code.

WCBossPhaseData Asset

Boss Phase Struct (FWCBossPhase)

Setting Up a Boss

1. Create Boss Phase Data

   Right-click → Data Asset → WCBossPhaseData. Add phases — e.g. Phase 0 (100%), Phase 1 triggers at 70% health, Phase 2 at 40%, Phase 3 (final) at 15%.

2. Assign to the Combat AI Component

   On the boss AI character Blueprint, select WCCombatAIComponent and set Boss Phase Data to your new asset.

3. Create Phase-Specific Gameplay Effects

   For each phase, create GEs for the stat changes. Example: Phase 2 GE grants +50% movement speed, +30% attack, removes slow walk animation tag.

4. Add Phase Decorators to BT

   In your boss's Behavior Tree, use BTDecorator_WC_IsInBossPhase on branches to run different logic per phase. Alternatively, specify a BehaviorTreeOverride per phase in the Data Asset for a complete swap.

5. Test

   Use console command WCBoss.ForcePhase <PhaseIndex> on the boss actor to instantly trigger a phase transition for testing.

🌍 World Context System

The World Context System lets the environment itself apply GAS effects to characters. Place AWCWorldContextVolume actors in your world and characters automatically receive configured Gameplay Effects while inside the volume — and have them removed on exit.

Use Cases

• Lava Zone: Characters inside take periodic fire damage (a ticking GE)
• Blizzard Area: Speed and regen are penalized (debuff GE)
• Sacred Grove: Health regeneration greatly increased (buff GE)
• Dark Cavern: Perception/vision attributes reduced (debuff GE)
• Day/Night: Bridge to the Calendar subsystem — daytime gives different bonuses than night

AWCWorldContextVolume Setup

1. Place the Volume

   Search Content Browser or the Place menu for WCWorldContextVolume. Drag it into the level. Resize with the standard Unreal brush tools to cover your environmental area.

2. Create World Context Data

   Right-click → Data Asset → WCWorldContextData. Configure:

   • ContextTag: e.g. WC.WorldContext.LavaZone
   • GameplayEffectsToApply: Add your lava damage GE (Infinite duration, periodic tick, fire damage)
   • AffectedActorFilter: Which actor classes react (leave empty for all actors with ASC)
   • Priority: When multiple volumes overlap, higher priority wins or combines (configurable)

3. Assign to the Volume

   Select your placed volume actor and in the Details panel, set World Context Data to your new asset.

WCWorldContextBridge

The UWCWorldContextBridge component links the World Context System to other systems (Calendar, Difficulty). It allows context effects to change dynamically — for example, a forest volume that applies different GEs at night vs. daytime based on a Calendar query.

// The Bridge queries the calendar and applies conditionally:
// WorldContext Volume: "Enchanted Forest"
// Day Context: GE_ForestRegen (health regen bonus)
// Night Context: GE_ForestHunted (periodic fear chance)
// Bridge reads UWCCalendarSubsystem::GetCurrentTimeOfDay() each tick

🔄 Transfer System

The Transfer System provides a structured mechanism for moving attribute values, abilities, or Gameplay Effects between actors at runtime. This powers mechanics like:

• Life Drain: Attacker steals Health from target
• Mana Siphon: Spell drains target Mana, adds it to caster Mana
• Buff Transfer: Support ability moves a buff GE from caster to ally
• Curse Transfer: Cleanse spell moves a status effect from ally to enemy

Transfer Types (WCTransferTypes)

Executing a Transfer

// Blueprint via UWCTransferFuncLib:
// Transfer 50 Health from Target to Caster (Life Drain)
FWCTransferRequest Request;
Request.TransferType = EWCTransferType::AttributeValue;
Request.AttributeTag = FGameplayTag::RequestGameplayTag("WC.Attribute.Health");
Request.Amount = 50.f;
Request.Source = TargetActor;   // Where value comes FROM
Request.Destination = CasterActor; // Where value GOES TO
Request.bCappedBySourceCurrent = true; // Don't drain more than target has

UWCTransferSubsystem::ExecuteTransfer(GetWorld(), Request);

⚙️ Difficulty System

The Difficulty System applies global multipliers and modifiers across all characters based on the active difficulty tier. It is a Game Instance Subsystem, so it persists across level loads.

WCDifficultyTier Asset

// Change difficulty tier at runtime (from main menu, settings, etc.)
if (UWCDifficultySubsystem* Difficulty = GetGameInstance()->GetSubsystem<UWCDifficultySubsystem>())
{
    Difficulty->SetDifficulty(DA_WC_Difficulty_Nightmare);
}

⚔️ Faction System

The Faction System defines relationships between groups of actors. It drives AI target selection (attack enemies, help allies), EQS queries, and UI display of faction standing.

WCFactionRelations Asset

A faction relations asset defines all faction-to-faction relationships. Each entry is a pair of faction tags and a relationship type:

WCFactionAgent Component

Add UWCFactionAgentComponent to any actor to make it faction-aware:

// Get this actor's current faction tag
FGameplayTag Faction = FactionAgent->GetCurrentFaction();

// Change faction at runtime (e.g. player betrays their guild)
FactionAgent->SetFaction(FGameplayTag::RequestGameplayTag("WC.Faction.Bandits"));

// Query relationship between two actors
EWCFactionRelationship Relation = 
    UWCFactionLibrary::GetRelationship(ActorA, ActorB);

💧 Overflow System

The Overflow System handles what happens when an attribute receives more modification than it can absorb. Instead of silently discarding excess, overflow can be routed to another attribute or system.

Common Use Cases

Configuring Overflow

Overflow rules are configured per-attribute in the WCGASAttributeDefinition. Set:

• OverflowAttributeTag: The attribute that receives overflow (e.g. WC.Attribute.Shield)
• OverflowMultiplier: How much of the overflow is transferred (0.0–1.0). 1.0 = full overflow, 0.5 = half.
• OverflowEventTag: Gameplay Event sent when overflow occurs (bind for VFX or ability triggers)
• bClearOnThreshold: If true, once overflow attribute fills, it is cleared and OverflowEventTag fires

🔬 Deep Dive: Custom Attributes Advanced

While the Attribute Definition Data Asset covers most cases, some games need fully custom attribute behavior. Here is the complete process for creating an attribute system extension in C++.

Step 1 — Create an Attribute Definition Asset

Even for custom attributes, always start with a WCGASAttributeDefinition Data Asset. Set the attribute tag to your new tag, configure base/min/max, and register it in Project Settings. This ensures it is part of the pool.

Step 2 — Create a Custom MMC (if needed)

If your formula type is Custom, subclass UGameplayModMagnitudeCalculation:

UCLASS()
class UMyGame_MMC_ManaFromIntelligence : public UGameplayModMagnitudeCalculation
{
    GENERATED_BODY()
public:
    UMyGame_MMC_ManaFromIntelligence();

    virtual float CalculateBaseMagnitude_Implementation(
        const FGameplayEffectSpec& Spec) const override;

private:
    FGameplayEffectAttributeCaptureDefinition IntelligenceDef;
};

// In .cpp
UMyGame_MMC_ManaFromIntelligence::UMyGame_MMC_ManaFromIntelligence()
{
    // Capture Intelligence attribute from the Source
    IntelligenceDef = FGameplayEffectAttributeCaptureDefinition(
        UWCAttributeSet::GetIntelligenceAttribute(), // Get via pool accessor
        EGameplayEffectAttributeCaptureSource::Source,
        false // don't snapshot
    );
    RelevantAttributesToCapture.Add(IntelligenceDef);
}

float UMyGame_MMC_ManaFromIntelligence::CalculateBaseMagnitude_Implementation(
    const FGameplayEffectSpec& Spec) const
{
    FAggregatorEvaluateParameters Params;
    Params.SourceTags = Spec.CapturedSourceTags.GetAggregatedTags();
    float Intelligence = 0.f;
    GetCapturedAttributeMagnitude(IntelligenceDef, Spec, Params, Intelligence);
    return Intelligence * 5.0f; // 1 Intelligence = 5 Max Mana
}

Step 3 — Reference the MMC in a Gameplay Effect

Create a Gameplay Effect. Add a Modifier targeting your attribute with Magnitude Calculation Class set to your custom MMC. Apply this GE on character init (or via the Attribute Initializer component).

Step 4 — Listen for Changes

// Bind to attribute changes for reactive UI or logic
ASC->GetGameplayAttributeValueChangeDelegate(
    UWCAttributeSet::GetAttributeFromTag(MyAttributeTag)
).AddUObject(this, &ThisClass::OnMyAttributeChanged);

🔬 Deep Dive: Custom Status Effects Advanced

Beyond data-driven effects, you can create fully custom status effect behavior by subclassing the status processing pipeline.

Custom Per-Tick Processing

If a data-driven Tick GE isn't enough, implement a custom UWCStatusEffect_CustomTick class:

UCLASS()
class UMyStatus_FrostbiteTick : public UWCStatusEffect_CustomTick
{
    GENERATED_BODY()
public:
    virtual void ProcessTick(
        UAbilitySystemComponent* TargetASC,
        const FWCStatusEffectState& State,
        float DeltaTime) override
    {
        // Scale damage with current stack count
        float Damage = State.CurrentStacks * 3.0f;

        // Apply damage GE manually
        FGameplayEffectContextHandle Context = TargetASC->MakeEffectContext();
        // ... apply your custom GE
    }
};

Custom Evolution Conditions

For evolution conditions beyond the built-in triggers, subclass UWCStatusEvolutionCondition:

UCLASS()
class UMyEvolution_MoonlightCondition : public UWCStatusEvolutionCondition
{
    GENERATED_BODY()
public:
    virtual bool EvaluateCondition(
        UAbilitySystemComponent* TargetASC,
        const FWCStatusEffectState& State) const override
    {
        // Evolve only at night (reading the calendar subsystem)
        UWCWorldContextSubsystem* WorldCtx = GetWorld()->GetSubsystem<UWCWorldContextSubsystem>();
        return WorldCtx && WorldCtx->IsNightTime();
    }
};

🔬 Deep Dive: Custom Resistance Rules Advanced

If you need resistance behavior beyond the four standard layers (e.g. block-based parry mechanics, damage reflection, conditional resistance), you can inject custom resistance logic into the pipeline.

The Resistance Pipeline Hook

Override UWCResistanceComponent::OnPreDamageApplied in a Blueprint subclass of the component — or in C++ via the delegate:

// C++: Bind to the pre-damage delegate on the component
ResistanceComp->OnPreDamageApplied.AddDynamic(
    this, &ThisClass::CustomResistanceHook);

void AMyCharacter::CustomResistanceHook(
    FWCDamageInfo& DamageInfo)
{
    // Reflect 20% of physical damage back at the attacker
    if (DamageInfo.DamageTypeTag.MatchesTag(TAG_DamageType_Physical))
    {
        float Reflected = DamageInfo.FinalDamage * 0.2f;
        // Apply reflected damage to DamageInfo.Instigator
        // Reduce DamageInfo.FinalDamage by reflected amount
        DamageInfo.FinalDamage -= Reflected;
    }
}

🔬 Deep Dive: Custom Heritage Blessings Advanced

Heritage Blessings are special passive effects that go beyond simple attribute modifiers. They are defined as a combination of a Gameplay Tag, a Gameplay Effect, and optional Blueprint logic.

Creating a Complex Blessing

Example: "Dragon's Blessing" — while the character is below 30% health, they deal 50% more damage.

1. Create the Conditional GE

   Create a Gameplay Effect with a Modifier on your damage output attribute. Set Modifier Magnitude to use a Conditional formula type (from the 12 formula types list). The condition tag: WC.Status.LowHealth.

2. Create the "LowHealth" Tag Setter

   Create a second Gameplay Effect that adds tag WC.Status.LowHealth and remove it when not triggered. Use a GE with a Health threshold checker — or use a custom UWCGEComponent_AttributeThresholdTag component on the GE that automatically adds/removes the tag when the attribute crosses 30%.

3. Add Both GEs to the Blessing

   In the WCHeritage_RaceDefinition, add both GEs to GrantedGameplayEffects with Infinite duration. They will be active as long as the heritage is applied.

🌐 Multiplayer Guide

GAS Ally is designed server-authoritative from the ground up. All gameplay-critical state modifications happen on the server and replicate to clients. This section documents which systems are server-only, which replicate, and how to avoid common pitfalls.

Replication Summary

Critical Rules

Prediction

GAS Ally supports Gameplay Ability System's native client-side prediction. For player-initiated abilities:

• Activate abilities through the GAS standard TryActivateAbility path — this automatically uses prediction keys
• Status Effect visuals (VFX, UI icons) can be client-predicted by listening to GAS OnGameplayEffectAdded with the status tag
• Never predict damage values on clients; damage always resolves server-side

Testing Multiplayer Locally

1. Set Player Count

   In the Unreal Editor toolbar, set Play As: 2 Players in the Play dropdown.

2. Use Net Mode: Listen Server

   Set Net Mode: Play As Listen Server so one client is also the server — ideal for local co-op testing.

3. Monitor Replication

   Use WCGASDebugCommands console commands (see Debug section) to inspect attribute values and active GEs on both the server and client windows simultaneously.

📋 Class Reference

Runtime Module (WCGASAlly) — Key Classes

Editor Module (WCGASAllyEditor) — Key Classes

🏷️ Tag Reference

GAS Ally uses the WC.GASAlly.* tag namespace. All tags are defined in the WCGASAlly module's tag files and should not be duplicated in your project.

Character State Tags

Status Effect Tags (Common Examples)

Damage Type Tags

Event Tags

Heritage Tags

📐 Blueprint API

GAS Ally exposes a comprehensive set of Blueprint function libraries so you can access all systems without writing C++.

UWCHeritageLibrary

UWCLevelingLibrary

UWCStatusEffectLibrary

UWCResistanceLibrary

UWCFactionLibrary

UWCDamageCalcLibrary

🐛 Debug & Console Commands

GAS Ally provides a rich set of debug tools accessible via the console (tilde key ~ or `) and via the Gameplay Debugger.

Gameplay Debugger

Press ` (backtick) in PIE, then press 5 to activate the WCGASAlly debug category. Click any character to inspect their live GAS Ally state:

• All attribute current/base/max values from the pool
• Active status effects with stack counts and remaining duration
• Active Gameplay Effects and their expiry timers
• Threat table (for AI characters)
• Boss phase index (for bosses)
• Heritage race/class tags
• Current level and XP progress

Console Commands

🔧 Troubleshooting

Build Errors

Runtime Issues

Performance Issues