Example: Dodge Roll¶

Overview¶

A dodge roll ability that grants invulnerability frames (i-frames) during the animation, costs stamina, and blocks other abilities while rolling. This demonstrates how Activation Owned Tags create temporary character states, how those states integrate with the damage pipeline, and how Activation Blocked Tags prevent re-rolling mid-dodge. The roll uses root motion from the montage for physically grounded movement.

What We're Building¶

• Stamina cost of 20 per roll
• Short cooldown of 0.5 seconds to prevent roll spam
• I-frames during the entire roll animation via State.Invulnerable tag
• Root motion movement -- the dodge distance comes from the animation, not manual velocity
• Ability blocking -- can't attack or re-roll while rolling
• CC blocking -- can't roll while stunned or dead
• Tags as state -- State.Evading and State.Invulnerable are granted automatically on activation and removed on end

Prerequisites¶

Step 1: Create the Effects¶

The dodge roll only needs two effects -- a cost and a cooldown. There is no damage effect because the dodge doesn't deal damage. The i-frame behavior comes entirely from tags, not from a Gameplay Effect.

GE_Cost_DodgeRoll¶

GE_Cooldown_DodgeRoll¶

We use Cooldown.Evade rather than Cooldown.Ability.DodgeRoll because you might have multiple evasion abilities (dodge, dash, blink) that share a single cooldown. If you want independent cooldowns per evasion type, use more specific tags like Cooldown.Evade.DodgeRoll.

Step 2: Create the Ability¶

Create a new Blueprint class with YourProjectGameplayAbility as the parent. Name it GA_DodgeRoll.

Class Defaults¶

Event Graph¶

flowchart LR
    A["ActivateAbility"]:::event --> B["CommitAbility"]:::func
    B -->|Failed| C["EndAbility\n(cancelled)"]:::endpoint
    B -->|Success| D["PlayMontageAndWait\nAM_DodgeRoll"]:::task
    D -->|Completed / BlendOut| E["EndAbility"]:::endpoint
    D -->|Interrupted / Cancelled| E

    classDef event fill:#5c1a1a,stroke:#ff6666,color:#fff
    classDef func fill:#2a2a4a,stroke:#9b89f5,color:#fff
    classDef task fill:#1a3a5c,stroke:#4a9eff,color:#fff
    classDef endpoint fill:#1a4a2d,stroke:#6bcb3a,color:#fff

void UGA_DodgeRoll::ActivateAbility(
    const FGameplayAbilitySpecHandle Handle,
    const FGameplayAbilityActorInfo* ActorInfo,
    const FGameplayAbilityActivationInfo ActivationInfo,
    const FGameplayEventData* TriggerEventData)
{
    if (!CommitAbility(Handle, ActorInfo, ActivationInfo))
    {
        EndAbility(Handle, ActorInfo, ActivationInfo, true, true);
        return;
    }

    UAbilityTask_PlayMontageAndWait* MontageTask =
        UAbilityTask_PlayMontageAndWait::CreatePlayMontageAndWaitProxy(
            this,
            NAME_None,
            DodgeMontage,  // UPROPERTY: TObjectPtr<UAnimMontage>
            1.0f);

    MontageTask->OnCompleted.AddDynamic(
        this, &UGA_DodgeRoll::OnMontageFinished);
    MontageTask->OnBlendOut.AddDynamic(
        this, &UGA_DodgeRoll::OnMontageFinished);
    MontageTask->OnInterrupted.AddDynamic(
        this, &UGA_DodgeRoll::OnMontageCancelled);
    MontageTask->OnCancelled.AddDynamic(
        this, &UGA_DodgeRoll::OnMontageCancelled);
    MontageTask->ReadyForActivation();
}

void UGA_DodgeRoll::OnMontageFinished()
{
    EndAbility(
        CurrentSpecHandle,
        CurrentActorInfo,
        CurrentActivationInfo,
        true, false);
}

void UGA_DodgeRoll::OnMontageCancelled()
{
    EndAbility(
        CurrentSpecHandle,
        CurrentActorInfo,
        CurrentActivationInfo,
        true, true);
}

I-Frames: How State.Invulnerable Works in the Damage Pipeline¶

The State.Invulnerable tag doesn't do anything on its own -- your damage pipeline needs to check for it. There are two approaches:

void UYourAttributeSet::PostGameplayEffectExecute(
    const FGameplayEffectModCallbackData& Data)
{
    // ... other processing ...

    if (Data.EvaluatedData.Attribute ==
        GetPendingDamageAttribute())
    {
        UAbilitySystemComponent* TargetASC =
            Data.Target.AbilityActorInfo->AbilitySystemComponent.Get();

        if (TargetASC && TargetASC->HasMatchingGameplayTag(
            FGameplayTag::RequestGameplayTag(
                FName("State.Invulnerable"))))
        {
            // Target is invulnerable -- zero out the damage
            SetPendingDamage(0.f);
            return;
        }

        // Normal damage processing continues...
        const float FinalDamage = GetPendingDamage();
        SetPendingDamage(0.f);
        SetHealth(FMath::Clamp(
            GetHealth() - FinalDamage, 0.f, GetMaxHealth()));
    }
}

Step 3: Wire Input¶

1. InputAction Asset¶

Create IA_Dodge (right-click > Input > Input Action). Set the Value Type to Digital (Bool).

2. InputMappingContext¶

In your IMC_Default, add:

• Input Action: IA_Dodge
• Key: Space bar, B button, or your preferred dodge key

3. Route Input to the ASC¶

// Same pattern as the melee attack input binding,
// but matching InputTag.Movement.Dodge instead
EnhancedInput->BindAction(
    DodgeAction,  // UPROPERTY: TObjectPtr<UInputAction>
    ETriggerEvent::Started,
    this, &AYourCharacter::OnDodgeInput);

See Input Binding for the full production input routing setup.

4. Grant the Ability¶

Add GA_DodgeRoll to your character's Startup Abilities array in Class Defaults.

Step 4: Test¶

Basic Test¶

1. Hit Play
2. Press your dodge key -- character should play the roll animation and move via root motion
3. Stamina should decrease by 20
4. Press dodge again immediately -- should not activate (0.5s cooldown)
5. Wait 0.5 seconds -- dodge should work again

I-Frame Test¶

1. Set up a damage source (enemy attack, damage volume, or console command)
2. Time the damage to hit during the roll
3. Verify no damage is taken during the roll (State.Invulnerable is present)
4. Verify damage works normally before and after the roll

ShowDebug Checklist¶

Open the console and type showdebug abilitysystem:

Edge Cases¶

• Dodge at exactly 20 stamina -- should succeed (cost check is >=, not >)
• Interrupted by a force (knockback) -- montage interrupted, ability ends, tags removed, character is no longer invulnerable
• Network: dodge on client -- prediction should make the roll feel immediate. If the server rejects (out of stamina due to a race), the client rolls back

The Full Flow¶

Here's what happens from button press to roll completion:

1. Input fires IA_Dodge
2. Input handler finds abilities with InputTag.Movement.Dodge and calls TryActivateAbility
3. The ASC checks activation requirements:
   • Blocked tags: Does the owner have State.Dead, CrowdControl.Hard, or State.Evading?
4. If checks pass, the ability activates:
   • Activation Owned Tags are granted immediately: State.Evading, State.Invulnerable
   • ActivateAbility fires
5. CommitAbility checks cost and cooldown:
   • Cost: Do we have 20+ Stamina? If yes, apply GE_Cost_DodgeRoll (Stamina -20)
   • Cooldown: Apply GE_Cooldown_DodgeRoll (tag granted for 0.5 seconds)
   • If commit fails, End Ability is called immediately (tags are removed)
6. Play Montage and Wait starts AM_DodgeRoll with root motion. The character physically moves through space
7. During the roll, State.Invulnerable is on the ASC. Any incoming damage that checks this tag is zeroed out
8. During the roll, Block Abilities With Tag: Ability.Combat prevents combat abilities from activating
9. The montage completes. End Ability is called
10. Activation Owned Tags (State.Evading, State.Invulnerable) are automatically removed
11. After 0.5 seconds, the cooldown effect expires and Cooldown.Evade tag is removed. The dodge is available again

Variations¶

Directional Dodge¶

Instead of always rolling forward, use the player's movement input to determine roll direction. Before playing the montage, read the character's last movement input vector and select a directional montage section (Forward, Back, Left, Right). Pass the section name to PlayMontageAndWait via the StartSection parameter.

Dash (No Animation)¶

Replace the montage with a LaunchCharacter or direct velocity override. Use a short WaitDelay task (0.3 seconds) to control the i-frame duration. This is faster to set up and works well for top-down games where you don't need a roll animation.

Dodge with Stamina Regeneration Pause¶

Add a second Gameplay Effect -- GE_StaminaRegenPause -- with a duration of 1.5 seconds that applies a modifier blocking stamina regeneration. Apply it alongside the cost in ActivateAbility (after CommitAbility succeeds). This prevents the "dodge spam + regen" loop that trivializes stamina management.

Related Pages¶

• Melee Attack -- montage-driven ability with damage application
• Ranged Attack -- projectile spawning, passing GE specs to actors
• Ability Tasks -- PlayMontageAndWait details
• Cooldowns and Costs -- cost/cooldown deep dive
• Immunity -- the GE Component approach to i-frames
• Damage Pipeline -- where invulnerability is checked
• Tag Architecture -- designing State.* and CrowdControl.* tags