NEW V4 - ACF Ability System
The ACF aAbility System is one of the core gameplay pillars of ACF Ultimate.
Built entirely on top of Unreal’s Gameplay Ability System (GAS), it provides a modular, data-driven approach to define and execute complex player and AI actions such as attacks, skills, or contextual interactions.
Each action in ACF is represented by a Gameplay Ability subclass (UACFActionAbility) that plays a montage, applies gameplay effects, and synchronizes events through replication and gameplay tags.
In short: it’s a high-level ability framework designed for fast iteration, visual control through Blueprints, and maximum flexibility in multiplayer contexts.
Key Concepts
1. UACFAbilitySystemComponent
This component extends Unreal’s standard UAbilitySystemComponent to handle ACF-style abilities, combo logic, buffering, and priority-based action management.
You can find it already configured in all characters within the sample project.
It provides an extensive Blueprint API for triggering and managing abilities.

2. UACFActionAbility
UACFActionAbility is a specialized subclass of UGameplayAbility representing an animated action.
When triggered, it automatically plays an animation montage, optionally uses motion warping, and terminates itself when the animation ends.
You can derive new Blueprint-based actions from this class and define their behavior directly in editor.
Each UACFActionAbility represents a single action, like an attack,an hit reaction, dodge roll, or special move.
Configurable from Data Assets
Every UACFActionAbility reads its configuration from a Data Asset, specifically an UACFAbilitySet
That means you can configure:
The montage to play,
The Gameplay Effects to apply (damage, cost, cooldown, buffs, etc.),
The Gameplay Tags used to trigger or reference the action,
And even the effect magnitudes — dynamically, using SetByCaller tags.
This data-driven approach lets you define dozens of abilities without ever creating separate Blueprint classes.
You just reuse one base ability class and feed it different Data Assets.
3. UACFAbilitySet
This is a Data Asset used to define collections of abilities granted to a character.
Each ability entry includes:
The class of the ability,
The trigger tag,
The ability level,
(Optional) action-specific data.
In the sample project, each moveset or character references an AbilitySet to initialize its available actions.
You can browse them directly under the Data/Abilities folder and tweak values without touching code.
4. UACFSustainedAction
A subclass of UACFActionAbility used for charge or hold actions (e.g., bow charging or continuous attacks).
It tracks elapsed time, exposes a ReleaseAction() Blueprint function, and cleanly handles state transitions between start, hold, and release.
How to Use It in Blueprints
The Actions System in ACF is fully Blueprint-ready.
All sample project characters are pre-configured with the ACF Ability Component, so you can focus directly on logic and data — no setup required.
Here’s how it works in practice:
Triggering an Action
From any Blueprint (Player Controller, Character, or Input Mapping Context), you can call:
TriggerActionAbility (AbilityTag)
Example:
ACFAbilitySystemComponent → TriggerActionAbility
AbilityTag = Action.Attack.Light
This will:
Trigger the corresponding
UACFActionAbility.Play the associated montage.
Broadcast the
OnAbilityStartedEvent.Automatically handle cooldowns, priorities, and replication.
Checking Action State
You can easily query the component to know what’s happening:
IsPerformingAction() → returns true if an action is active
GetCurrentActionTag() → returns the tag of the current ability
GetCurrentActionPriority() → returns its priority
These are ideal for UI logic (e.g., disabling buttons while attacking) or combo management.
Changing Movesets Abilities
The system supports dynamic moveset switching (for example, changing from melee to ranged):
SetMovesetActions(NewMovesetTag)
This automatically removes the old ability set and grants the new one defined in the MovesetAbilities map. Is done automatically when equipping a weapon.
Gameplay Events
To trigger a gameplay event to all active abilities (for instance, when a hit lands):
TriggerGameplayEvent(EventTag)
This calls OnGameplayEventReceived inside each running UACFActionAbility.
Why It’s Powerful
Unlike traditional hardcoded systems, ACF’s Actions System is:
Modular – each action is an independent ability, easily replaced or extended.
Data-Driven – behaviors, inputs, and cooldowns are configured via Data Assets, not code.
Network-Ready – full server-authoritative design with replicated tags and events.
Fully Blueprint-Exposed – every key function can be triggered or queried from Blueprints.
Integrated – it seamlessly ties with ACF’s combat, attributes, animation layers, and AI systems.
Typical Blueprint Workflow
In the sample project, all of this is already wired up — here’s what you’ll see in practice:
Press Input → Calls TriggerActionAbility with a Gameplay Tag.
ActionAbility activates → plays montage and applies gameplay effects.
Animation triggers ACFNotifies → sends Gameplay Events back to the Ability.
Ability handles damage, transitions, or FX → optionally queues next combo input.
Montage ends → ability deactivates automatically.
This means every sword swing, spell, or special move in ACF follows the same consistent and extensible pattern.
Extending the System
You can easily create your own action types:
Derive from UACFActionAbility for standard actions.
Derive from UACFSustainedAction for hold/release mechanics.
Or even make custom ability classes with your own Blueprint logic, still benefiting from the ACF runtime logic (cooldowns, priorities, buffering).