Gameplay Ability System

What the ability does. Override this in subclasses. Called after CanActivate passes.

Const check — no side effects. Verifies cooldowns, costs, tags, and requirements.

Commits resources (mana, stamina). Call this from ActivateAbility. Last chance to fail.

Commits only the cost portion. Use when you want to separate cost from cooldown.

Commits only the cooldown. Use when you want to separate cooldown from cost.

Called when the ability finishes, whether it succeeded or was cancelled.

Called when the ability is forcibly interrupted from outside.

Returns whether the ability is off cooldown. No side effects.

Returns whether the owner can afford the ability cost. No side effects.

Deprecated since 5.5. Shared CDO, no per-instance state. Use InstancedPerActor instead.

One instance per owning actor. Shared across activations. Recommended default.

New instance each activation. Most flexible but higher memory cost.

Client predicts activation, server confirms. Best for responsive gameplay.

Runs only on the local machine that has control. No server involvement, no prediction.

Client requests, server decides. More authoritative, slightly more latency.

Runs only on the server. Use for abilities that don't need client-side prediction.

Initialize the ASC with the owning actor and avatar actor. Call once during setup.

Grant an ability to this component. Returns a handle for later reference.

Grant and immediately activate. The ability is removed after it finishes.

Attempt to activate an ability by its spec handle.

Attempt to activate all abilities matching the given tags.

Cancel a specific active ability.

Cancel active abilities matching tag filters.

Cancel every active ability on this component.

Apply a gameplay effect to this component.

Apply a gameplay effect to another ASC.

Remove an active effect by its handle. Pass StacksToRemove for partial removal.

Remove effects matching a class and source ASC.

Get an attribute set by type. Returns null if not found.

Get the current value of an attribute.

Get the base (permanent) value of an attribute.

Set the base value directly, bypassing the GE system.

Returns true if the component has the exact tag or a parent of it.

Returns true if the component has all of the specified tags.

Returns true if the component has any of the specified tags.

Add a tag directly, not through a gameplay effect.

Remove a directly-added tag.

Applies once and disappears. Damage hits, one-off heals, permanent stat changes.

Active for N seconds, then expires. Timed buffs like +10 speed for 5 seconds.

Stays active until explicitly removed. Passives, equipment bonuses, persistent states.

Add to base value before multipliers.

Stack multipliers additively. Two +50% buffs = 1 + 0.5 + 0.5 = 2x.

Stack divisors additively.

Compound multipliers. Two 1.5x buffs = 1.5 * 1.5 = 2.25x.

Add to the final value after all multipliers.

Replace the entire value. Highest priority wins. Legacy — exists for serialization compatibility.

Fixed value that optionally scales with level via a curve table.

Derived from a target attribute. (Attribute * Coefficient + Bonus).

Subclass UGameplayModMagnitudeCalculation and implement CalculateBaseMagnitude.

Value set at runtime by the ability code. Look up by tag or name.

Each application is independent. Multiple DoTs from different sources all tick separately.

Stacks when the same source reapplies. Two warriors hitting the same target get separate stacks.

Stacks on reapplication to the same target regardless of source.

Called before a GE modifies the base value. Return false to reject the modification.

Called after a GE modifies the base value. Use for reactions like triggering death when Health hits zero.

Called before any attribute change. Can clamp NewValue.

Called after any attribute change. React to changes here.

Play an animation montage. Broadcasts OnCompleted, OnBlendedIn, OnBlendOut, OnInterrupted, OnCancelled.

Spawn a target actor and wait for the player to confirm targeting. Broadcasts ValidData, Cancelled.

Wait for a gameplay event with a specific tag. Broadcasts EventReceived.

Wait for N seconds. Broadcasts TimerFinished.

Wait for the ability's bound input to be pressed or released.

Wait for the ability system's generic confirm or cancel input.

Wait for an attribute to reach a threshold value. Broadcasts OnChange.

Wait for a gameplay effect to be applied to self or a target.

Wait for a specific tag to be added or removed from the owner.

Spawn an actor with ExposeOnSpawn support. Broadcasts Success, DidNotSpawn.

Wait for server confirmation before proceeding. Used for prediction synchronization.

Apply movement during ability. Variants for jumps, constant forces, and curves.

One-shot cue. Damage hit, impact effect, pickup flash.

Start a persistent cue. Buff begins, shield activates.

Persistent cue ticking. Looping sound, ongoing particle effect.

End a persistent cue. Buff expires, shield deactivates.

Tags this ability has. Used for identification and queries.

Tags applied to the owner while the ability is active. Replicated.

Owner must have all of these tags for the ability to activate.

Owner must have none of these tags for the ability to activate.

When this ability activates, cancel other active abilities with matching tags.

While this ability is active, block other abilities with matching tags from activating.

Tags granted to the target while the effect is active. Replaces the deprecated InheritableOwnedTagsContainer (5.3+).

Meta tags on the effect itself for identification and filtering. Replaces InheritableGameplayEffectTags (5.3+).

Blocks the effect if the target has matching immunity tags. Replaces GrantedApplicationImmunityTags (5.3+).

Tags the target must have (or must not have) for the effect to apply. Replaces ApplicationTagRequirements (5.3+).

Removes other active effects that match specified tags when this effect is applied (5.3+).

Unique FGameplayAbilitySpecHandle. Use this to reference the ability later.

Pointer to the ability class (CDO or instance depending on instancing policy).

Ability level. Affects scalable float curves and damage scaling.

Input binding index. INDEX_NONE if not bound to input.

What granted this ability — an item, a talent, a pickup.

How many instances are currently active.

Whether the bound input is currently held down.

Ability is removed from the ASC after this activation completes.

Source tags for GEs created by this spec. Replaces the deprecated DynamicAbilityTags field (5.5+).

Override this. Read captured attributes from ExecutionParams, write modifier results to OutExecutionOutput.

Read a captured attribute's current value (base + modifiers). Returns false if capture failed.

Read only the base value of a captured attribute, ignoring active modifiers.

Macro to declare a capture definition in your header. Creates PropertyName##Property and PropertyName##Def members.

Macro to initialize a capture definition in your constructor. Source is Source or Target, bSnapshot freezes the value at spec creation.

Override this. Return the calculated magnitude. The Spec gives you access to source/target tags and SetByCaller values.

Blueprint-accessible helper to read a captured attribute value with tag filtering.

Read a SetByCaller value from the spec using a gameplay tag.

Grants gameplay abilities to the target while the effect is active. Configurable level and input binding.

Applies additional GEs on application, on normal completion, on premature removal, or always.

Tags that the GE itself has for identification and queries. Not transferred to actors.

Blocks activation of abilities with matching tags while the effect is active.

Cancels active abilities with matching tags on application or execution.

Probabilistic application. Uses FScalableFloat for dynamic chance calculation.

Custom application requirements via UGameplayEffectCustomApplicationRequirement subclasses.

Blocks application of other GEs matching a FGameplayEffectQuery. Requires duration.

Removes active GEs matching a FGameplayEffectQuery when this effect is applied.

Tag requirements on the target for application, continuation, and removal.

Grants tags to the target actor while the effect is active.

Single hit result from a line trace or projectile. Contains an FHitResult.

Multiple actor targets with a source location. Use for AOE or radial attacks.

Location-based targeting with source and target transforms. Supports literal, actor, and socket transforms.

The actor that initiated the effect chain (the character who fired).

The physical actor that caused the effect (the projectile that hit).

The ability CDO that created this context.

Level of the ability when the context was created.

Abstract source — an item, weapon, or talent that triggered the chain.

FHitResult from the targeting system, if available.

World location where the effect originated.

The source ASC, cached for performance.

The actor that owns the ability system. Always valid.

The physical actor executing abilities. May differ from owner (e.g., player state owns ASC, pawn is the avatar).

Cached controller reference. Null for AI-controlled actors.

The ASC itself. Always valid after initialization.

Cached mesh for montage playback. Null if no skeletal mesh.

Cached anim instance for animation-driven abilities.

Cached movement component for movement abilities.

True only on the owning client. Use for client-only logic.

True on the server. Use for authority-only logic.

Generate a new prediction key for client-side prediction.

Create a prediction window on the server when receiving a client RPC. Side effects inside this scope use the key.

Returns true if the key has a valid ID (Current > 0).

True if generated locally on a client.

Register a callback that fires if the server rejects this prediction.

Register a callback that fires when replicated state catches up to this prediction.