Introduction

The Aura System:

As final project at FutureGames we decided to do a first person, hack n' slash, rogue-like dungeon crawler where you slay enemies and collect various buffs to enhance your abilities and make you stronger. For this I wanted to make a fully customizeable buff & debuff system. This system was heavily inspired by how World Of Warcrafts buffs & debuffs work which I decided to call Aura or the Aura System. This system was built in Unreal Engine 5 with C++.

How it works:

The Aura system is based on 3 key components.

First the Auras themselves, these are the customizable effects that can react on muiltiple different activations depending on how you want it to function, these effects can range from dealing damage, healing the target, increase movement speed and so much more.

Second is the AuraCharacters which is a Pawn or PlayerCharacter that auras can be applied on. AuraCharacters also handle the update and removing of Auras.

Third is the AuraHandler which holds all the created auras and is used to cast a specified Aura on a target.

Auras

Aura Events:

I wanted Auras to be a simple to use and fully customizable so that designers and other programmers could make effects that affect the player or enemies in fun and interesting ways. I also wanted to take advantage of Blueprints so that making an Aura is as accessible as possible.

Auras comes with many different functions that all get called on a particular events. These functions are then handled in Blueprints where you decide what you want to happen when that event is called.

In Code:

Auras have many variables that are initialized at it's creation, these are mostly used to keep track of the Aura and it's life cycle but also allows for the user to define events inside the aura functions if for example we want something to happen whenever the aura reaches a certain amount of stacks.

In Blueprint:

There are also different types of Auras that define their behaviour and what events they will react to. For example if you define an Aura to be a type of EFFECT you can then specify what attack you want it to call it's event from.

The Power of Auras:

Example below is an Aura that is a buff on the player that waits for when a specific attack hits an enemy, in this example it's the Fire Attack and when the Aura detects that the attack has hit en enemy, OnAuraAttackHit is called and we cast a debuff named Living Bomb on to the enemy.

When applied, the Living Bomb Aura does very little damage every tick (tick is in this case equal to every second) for a short duration. If the enemy dies with the debuff active it spawns an explosion, dealing damage and applying the same debuff to all surrounding enemies.

Showcase of how the Aura works. Each enemy in the line has increased health to show that the explosion won't spawn if the enemy doesn't die during it's duration.

Aura Character

Calling on Aura Events:

AuraCharacter is a virtual class that all Pawn or Player Characters in the game need to override if they want to use the Aura System. This class handles their own Auras that are applied to them, Updating and removing them whenever they are finished as well as calling their specific events whenever they are called (Update, AttackHit, Tick, etc).

Update function handles OnAuraUpdate, Tick and Removed.

OnAuraCast and Exist are actually called in AuraHandler but wanted to show it with all the others functions.

Calls when an Attack has hit an Enemy.

Calls when an attack has been casted.

Calls when this AuraCharacter has been damaged by an enemy.

OnAuraRemoved is also called when an AuraCharacter dies.

How Auras can affect an AuraCharacter:

AuraCharacters have a component called CharacterStats which hold many important values that Auras can affect.

There is the BaseStats component and the CombinedStats component. BaseStats is the default value that CombinedStats uses at the start of every Update which then depending on the Auras gets affected and changed. This can be movement speed reduction to dealing more damage with a certain element. CombinedStats is the value that is used for everything the AuraCharacter does. Example below is an Aura that increases the movement speed everytime it's casted stacking up to 5x.

Aura Showcase:

Aura Handler

Pooling and Handling of Auras:

AuraHandler holds all the available Auras thats been created. Each Aura pools X amount of itself depending on what the use case of the Aura is. If the Aura is a buff that will only be applied once on the player then the pool count can be set to 1. However if an Aura will affect multiple enemies at the same time then the pool count needs to be quite large to support that.

On initialization all the Auras are fetched and we assign their ID's name and default properties as well as start the pooling process of each Aura.

Now that the pooling process is finished we can now cast the Auras on any AuraCharacter.

When we fetch a pooled aura I check which of the Auras in the pooled list aren't active(active Auras means it's applied to an AuraCharacters.), reset it and return a pointer of it. If we don't find any available ones we just return NULL.

Summary

My Thougths:

This has been one of my favourite systems/tools to work on, and the potential of this system if I keep improving it is enormous.
I want to realize it's full potential some day with more events, less separating of different AuraTypes so that one Aura can do greater things to affect a AuraCharacter.

If you want to you can check out my groups game Exsanguis where this system is used.

Thanks for taking your time reading!