Your First Ability¶

Time to build something real. We're going to create a complete melee attack ability that touches every piece of GAS — effects, tags, abilities, input, montages, and the damage pipeline. The goal isn't to build a production-ready combat system (we'll get there in Patterns); it's to see the full loop end-to-end so you understand how the pieces connect before deep-diving into any one of them.

What We're Building¶

A basic melee attack that:

• Costs stamina (15 per swing)
• Has a cooldown (1 second)
• Plays an animation (attack montage)
• Deals damage at a specific point in the animation (not on button press)
• Uses SetByCaller for the damage amount (data-driven, not hardcoded)

By the end of this page, you'll press a button, watch your character swing, see a hit register at the right moment in the animation, and watch the target's health drop.

Step 1: Create the Gameplay Effects¶

We create the effects first, before the ability. This is intentional — effects are the data that defines what an ability actually does. The ability is just the orchestrator that decides when and how to apply them. Think of effects as the nouns and the ability as the verb.

All three effects are created in the Unreal Editor. Right-click in the Content Browser and go to Blueprint Class, then select GameplayEffect as the parent class. You can also right-click and search "Gameplay Effect" directly.

GE_Cost_MeleeAttack¶

This effect represents the stamina cost. GAS checks costs automatically before an ability activates — if the character can't afford it, the ability simply won't fire. No manual checks needed.

GE_Cooldown_MeleeAttack¶

The cooldown effect uses GAS's built-in cooldown system. When an ability activates, it applies this effect. While the effect is active, the ability checks for the cooldown tag and blocks re-activation.

The magic is in the tag. Your ability will be configured to check for Cooldown.Ability.BasicAttack — while this effect is active and that tag is present on the ASC, the ability can't activate. When the 1-second duration expires, the effect is removed, the tag is removed, and the ability is available again. No timers, no manual cleanup.

GE_Damage_Melee¶

This is the damage effect. Instead of hardcoding a damage number, we use SetByCaller — the ability sets the damage value at runtime when it creates the effect spec. This means a single damage effect class can be reused with different damage values, and those values can come from attributes, data tables, or calculations.

Notice we target PendingDamage, not Health. This is the meta attribute pattern from Project Setup — damage flows into PendingDamage, gets processed in PostGameplayEffectExecute (armor, shields, etc.), and the final result is applied to Health. This gives you a single processing pipeline for all damage sources.

Step 2: Create the Ability Blueprint¶

Create a new Blueprint class in the Content Browser. The parent class should be your YourProjectGameplayAbility (the base ability class from Project Setup).

Name it something like GA_MeleeAttack.

Class Defaults¶

Open the Blueprint and set these in the Class Defaults panel:

Event Graph¶

Here's the ability logic. This runs when the ability activates (after cost and cooldown checks pass):

Event ActivateAbility
    │
    ▼
Play Montage and Wait (AM_MeleeAttack, rate 1.0)
    ├── On Completed ──────────► End Ability (End on all paths!)
    ├── On Interrupted ─────────► End Ability
    ├── On Cancelled ───────────► End Ability
    └── On Blend Out ───────────► (optional: End Ability)

Wait Gameplay Event (Tag: Event.Montage.MeleeHit)
    │
    ▼
Make Outgoing Gameplay Effect Spec (GE_Damage_Melee)
    │
    ▼
Assign Set By Caller Magnitude
    ├── Spec Handle: (from above)
    ├── Data Tag: SetByCaller.Damage
    └── Magnitude: 25.0
    │
    ▼
Apply Gameplay Effect Spec to Target
    ├── Spec: (from above)
    └── Target: Event Data → Target (from Wait Gameplay Event)

The AnimNotify¶

Open your attack montage (AM_MeleeAttack) in the Montage Editor. At the frame where the weapon should connect with a target, add an AnimNotify that sends a gameplay event:

1. Right-click the Notifies track at the desired frame
2. Add Notify > AN_SendGameplayEvent (or your custom notify class)
3. Set the Event Tag to Event.Montage.MeleeHit
4. The event payload should include the target actor (populated by your hit detection logic — a trace, overlap, etc.)

Step 3: Wire Up Input¶

You need three things to connect a keyboard/gamepad input to your ability:

1. InputAction Asset¶

Create an Input Action asset in the editor (right-click > Input > Input Action). Name it IA_PrimaryAttack. Set the Value Type to Digital (Bool) — it's a press, not an axis.

2. InputMappingContext¶

Open (or create) your Input Mapping Context (IMC_Default or similar). Add a mapping:

• Input Action: IA_PrimaryAttack
• Key: Left Mouse Button (or whatever you prefer)

3. Route Input to the ASC¶

The connection between Enhanced Input and GAS happens in your character's SetupPlayerInputComponent. The exact implementation depends on your input binding approach, but the core idea is:

When IA_PrimaryAttack fires, you find all granted abilities whose InputTag matches InputTag.Combat.Primary and try to activate them.

// In your character's SetupPlayerInputComponent:
void AYourProjectCharacterBase::SetupPlayerInputComponent(
    UInputComponent* PlayerInputComponent)
{
    Super::SetupPlayerInputComponent(PlayerInputComponent);

    if (UEnhancedInputComponent* EnhancedInput =
        Cast<UEnhancedInputComponent>(PlayerInputComponent))
    {
        // Bind the primary attack input action
        EnhancedInput->BindAction(
            PrimaryAttackAction, // UPROPERTY pointing to IA_PrimaryAttack
            ETriggerEvent::Started,
            this, &AYourProjectCharacterBase::OnPrimaryAttackInput);
    }
}

void AYourProjectCharacterBase::OnPrimaryAttackInput()
{
    if (!AbilitySystemComponent) return;

    // Find and activate abilities with matching InputTag
    for (FGameplayAbilitySpec& Spec :
         AbilitySystemComponent->GetActivatableAbilities())
    {
        if (const UYourProjectGameplayAbility* Ability =
            Cast<UYourProjectGameplayAbility>(Spec.Ability))
        {
            if (Ability->InputTag.MatchesTagExact(
                FGameplayTag::RequestGameplayTag(
                    FName("InputTag.Combat.Primary"))))
            {
                AbilitySystemComponent->TryActivateAbility(
                    Spec.Handle);
            }
        }
    }
}

Step 4: Grant the Ability to Your Character¶

Open your Character Blueprint (the one based on YourProjectCharacterBase). In Class Defaults, find the Startup Abilities array and add your GA_MeleeAttack class.

That's it. When the character spawns and InitializeAbilities runs (from Project Setup), this ability will be granted to the ASC and ready to activate.

Step 5: Test It¶

Quick Smoke Test¶

1. Place your character Blueprint in a level
2. Hit Play
3. Press your attack button — the character should play the attack montage
4. If you have a second character in range, they should take 25 damage

Debugging with ShowDebug¶

Open the console (`) and type:

showdebug abilitysystem

This overlay shows you everything happening in the ASC in real time:

• Granted Abilities — you should see GA_MeleeAttack listed
• Active Abilities — lights up while your attack is playing
• Active Effects — you'll see the cooldown effect appear for 1 second after attacking
• Attributes — watch Stamina drop by 15 each attack, Health drop on the target
• Tags — the cooldown tag appears and disappears

What Just Happened?¶

Let's trace the full flow one more time, now that you've seen every piece:

1. Input fires IA_PrimaryAttack
2. Your input handler finds abilities with InputTag.Combat.Primary and calls TryActivateAbility
3. The ASC checks: Can this ability activate? It evaluates:
   • Cost: Do we have 15+ Stamina? (checks GE_Cost_MeleeAttack)
   • Cooldown: Is Cooldown.Ability.BasicAttack tag present? (checks GE_Cooldown_MeleeAttack)
   • Blocked tags: Does the owner have State.Dead or CrowdControl.Hard?
4. If all checks pass, the ability activates:
   • Cost effect is applied (Stamina -15)
   • Cooldown effect is applied (tag granted for 1 second)
   • ActivateAbility fires in the Blueprint
5. The ability plays a montage and waits for the Event.Montage.MeleeHit gameplay event
6. An AnimNotify in the montage sends the event at the right frame
7. The ability creates a damage GE spec, sets the damage amount via SetByCaller, and applies it to the target
8. The target's PostGameplayEffectExecute processes PendingDamage and subtracts from Health
9. The montage completes, the ability calls End Ability

Every piece of GAS was involved. The ASC managed it. Tags controlled flow. Effects modified attributes. The ability orchestrated the sequence. This is the GAS loop.

What's Next¶

You've built an ability that works. But should everything be an ability? Jumping? Sprinting? Opening a door? Head to Should It Be an Ability? for the decision framework you'll use on every feature going forward.