Unreal Engine 5 Gameplay Ability System (GAS) Crash Course

Welcome to Section 2

We discuss the core parts of GAS, and what each part is responsible for when creating a GAS project

We add the Ability System Component to the Player State

We create our first gameplay abilities for the player-controlled Character

We create a function for giving startup Abilities

We learn how to create Gameplay Tags natively in C++

We learn how to activate abilities by specifying the Ability's Gameplay Tag.

We get some practice creating Abilities, giving them, and creating input callbacks for activating them.

We create a C++ class designated to be the parent class for our Gameplay Abilities

We make use of the Play Montage and Wait Ability Task to play montages in our Gameplay Abilities

Welcome to Section 3

We create a custom Anim Notify class that is capable of sending a Gameplay Event to the owning Actor

We create the Enemy C++ class that will serve as a base class for all Enemies in our game

We create a C++ class for our own custom Ability System Component and assign it to our Player and Enemy

We create the ability to automatically activate our Gameplay Abilities when given by checking for an ActivateOnGiven Gameplay Tag

We create a Hit React Gameplay Ability with the ActivateOnGiven tag and assign it to our Enemies

We do an overlap test from our Primary Gameplay Ability in C++ so we can configure the sphere overlap's collision settings

We send a Hit React Gameplay Event to enemies we hit with our overlap test

We create C++ code for calculating the hit direction

We create Hit React Animation Montages for our Enemy Characters and add Montage Sections for each direction

We add a Niagara System Notify to our Player Character's Primary Attack Montage

Welcome to Section 4

We create the Attribute Set class for our Characters to use and create replicated Gameplay Attributes for our game

We add the Attribute Set to the Player State and Enemy Character class

We create a Gameplay Effect for setting our Attributes to their initial values and apply it.

We create an Attribute Widget Component so we can respond to Attribute changes in our UI

We learn how to react to Gameplay Effect application in C++ code

We create an Attribute Widget class that is capable of linking up with a Gameplay Attribute so it can be updated by the Attribute Widget Component

We create Widget Blueprints for our Attribute Widget and configure them to respond to changes to specific Attributes

Now that we are able to respond to Attribute changes, we create a Damage Gameplay Effect to modify Health and show it in the health bar

We learn how to use Curve Tables to modify a Gameplay Effect's magnitude based on its level.

An important note on the logical AND and OR operators, particularly when used for early returns from functions.

We learn how to Level Up our Ability's Level at runtime

Welcome to Section 5

We respond to Health changes in native code so that our C++ classes can do what they need as Health reaches zero

We create our own Async Task that is capable of listening to Attribute Changes

We create a Gameplay Ability that uses our Async Task to listen for Attribute Changes

We create an Ability to trigger when a character's Health reaches zero

We create a Gameplay Effect that applies a Gameplay Tag to the target

We create a Gameplay Effect for resetting Attributes when a Character dies

We implement Character respawn on death

We learn how to access the Instigator for a Gameplay Event from within the Attribute Set C++ class

We add a HandleRespawn function to the Character base class for handling whatever we need when a Character respawns.

Welcome to Section 6

We create a Gameplay Ability that will allow Enemies to search for a valid target

We apply Move To functionality for our AI Enemies

We make our Enemy Characters rotate to face their target before attacking

We learn how to stop AI movement

We create the Attack Gameplay Ability for our Ranged Attacker

We convert our SearchForTarget Gameplay Ability to C++

We create an Actor to spawn as a projectile when the Ranged Enemy attacks

Sometimes, we want to apply a Gameplay Effect and set its value dynamically with code or Blueprints. We learn how to do this using Set by Caller Magnitudes

We create the Attack Montage for our Melee Enemy

We create a Notify State class to use for our Melee Enemy to detect hits

We convert our SearchForTarget Gameplay Ability to C++

We create a static function that will apply a Gameplay Effect, set its Damage Set by Caller Magnitude, and send a Gameplay Event

We create the Damage Gameplay Effect for the Melee Enemy

Welcome to Section 7

We create Hit React Animation Montages for the Player-controlled Character

We create a Gameplay Cue for our Player-controlled Character and use it to play a Hit React Animation Montage

We use Gameplay Cue Parameters to send a Payload to our Gameplay Cues, which can use that data to perform logic.

We implement Player Respawn

We block Player Input when the Player is dead, then reenable it again when the Player Respawns

We create a new type of Gameplay Cue designed for burst-type effects

We add a Camera Shake to our Gameplay Cues for some added effect

We block Hit Reactions when necessary

Welcome to Section 8

We set up our Secondary Ability to block Hit Reacts and Play an Animation Montage

We spawn an Emitter and play a Camera Shake for cosmetic effects in the Secondary Ability

We move our Overlap Test into a Static Function Library so that we can use it from anywhere

We implement a Knockback force on each Character hit by our Secondary Ability

Once our Enemies are airborne, we transition them into a separate animation state

We implement Damage on Enemies from our Secondary Ability

We create a Cost Gameplay Effect and add it to our Secondary Ability

We create a Cooldown Gameplay Effect and add it to our Secondary Ability

We add a Search Range parameter to our Enemies so we can configure them to only search when a Player is in range

We add a Damage Numbers Niagara system that will be spawned when our Health changes

We orient Projectiles so that they can accommodate for variations in target elevation

We add more cool features, such as Health Pickups, Changing Damage Number Color, Optionally respawning Enemies, and Occluding the Enemy Health Bar

You are challenged to implement your own Tertiary Gameplay Ability and share your progress with the Druid Mechanics Community!