Warden's Will

Gameplay Ability System

The Gameplay Ability System (GAS) is Unreal Engine's framework for everything a character can do in combat. Each ability, whether an attack, a dash or a special move, is a self-contained piece of logic that knows what it costs, how long it takes to recover and what it does to its target. Stats such as health, energy and shields live in attribute sets, and gameplay effects change them through one shared pipeline, from instant damage to buffs and status effects that tick over time.

In Warden's Will, this system is the heart of the gameplay. Damage, active abilities, passive effects and every other gameplay feature are built on top of it, so new abilities slot in without special cases.

Modular Characters

All playable characters run on the same Gameplay Ability System, built on top of Epic's Lyra framework and customized for the game's own needs. What sets each one apart is the set of abilities it is granted, covering both movement and combat: one character can fly, another dashes, another fires homing missiles, and another fights with a sword-dance move set. Because every ability is a self-contained module, each character is defined simply by the abilities it owns. The characters themselves were a team effort, while every core system of the Gameplay Ability System underneath them was built by me.

Auto-Targeting Ability Task

The Flyer's ultimate fires a volley of homing missiles that are spread evenly across every locked target. To drive it, I wrote a custom C++ ability task that turns target acquisition into a single, reusable Blueprint node.

On every refresh, the task gathers enemy pawns within range using a sphere overlap and filters out teammates through Lyra's team subsystem. From the remaining candidates, it locks onto the one closest to the center of the screen inside a configurable view cone, and a line trace confirms that the target isn't hidden behind cover.

Each lock is stored together with its on-screen marker. Targeting can be unique, so each lock lands on a different enemy, or switchable, where a new target replaces the oldest lock once the limit is reached. Markers are spawned only for the locally controlled player and attached to the target's skeletal mesh, and the task broadcasts delegates whenever a marker is created or updated so the ability's Blueprint can react.

Range, view angle, refresh rate, collision channels and the number of targets are all node inputs, so the task isn't tied to a single ability. In the Flyer's ultimate, the maximum target count comes straight from the number of rockets the ability spawns, and the rockets are then divided evenly between the locked targets.

Hover's Ultimate

Hover's ultimate, Ion Cannon, charges up and fires a sustained energy beam that tears through every enemy in its path. Like every other ultimate, it is a regular gameplay ability that runs on the same shared systems.

Attributes

Every stat in Warden's Will lives in a Gameplay Ability System attribute set, and I built the game's entire attribute layer. Starting from Lyra's health and combat sets, I split the stats into focused sets, each replicated to clients and clamped in its attribute callbacks:

Attributes in Action

Damage is resolved in a custom gameplay effect execution that I extended to capture attributes from both sides: base damage, critical chance, critical damage and outgoing damage from the attacker, and damage reduction from the target. For ranged weapon abilities, distance and physical-material falloff are applied on top. Only effects tagged as able to crit can roll a critical hit, and a critical hit tags the effect so other systems can recognize it.

Costs and cooldowns are driven by custom magnitude calculations (MMCs) I wrote to read attributes at runtime. Weapon heat cost scales with the heat generation multiplier, movement and dodge costs scale with their energy multipliers, and every ability cooldown scales with cooldown reduction, which is never allowed to bring a cooldown down to zero.

When damage lands, the health set sends an OnHit gameplay event to the attacker, carrying the tags of the ability that caused it. This is the event augments listen to, and the tags it carries are what the proc-chain filter checks. Augments, weapons and characters all change these values through gameplay effects, so every bonus flows through the same calculations.

Weapon Mechanics

Weapons in Warden's Will are built around a heat mechanic. Primary fire builds up heat, while secondary fire spends the heat that has been stored.

When a weapon is equipped, it applies its own set of abilities and gameplay effects to the character. Because everything a weapon does goes through the Gameplay Ability System, weapons stay modular and meet the game's networking requirements.

Longinus: its primary fire is a laser beam that deals continuous damage, while its secondary fire sends out a moving energy field that keeps damaging everything around it. The two interact: firing the laser into the field feeds it, making it grow, and the field also slows enemies down.

Star Forger: its primary fire launches an energy orb that pulses damage around it at regular intervals, while its secondary fire sends out a small black hole that pulls in enemies and even its own primary orbs.

Augment System

Augments are passive abilities built on the Gameplay Ability System. Each one listens for a gameplay event, such as an on-hit event, and activates on its own the moment its conditions are met, with no input from the player.

During a run, players collect new augments from augment chests found throughout the levels.

With more than 10 trigger types and close to 100 different augments, this was the most complex system I worked on.

Controlling Proc Chains

The hardest problem I tackled was the proc-chain logic: one augment triggering another. For example, damaging an enemy with the Rocket augment can trigger Thunder Strike, an augment that fires on damage. Thunder Strike's own damage, however, must never trigger Thunder Strike again.

To solve this, I built a filtering layer driven by gameplay tags inside the applied gameplay effects. Every instance of damage carries a defined gameplay tag, which is passed on to the gameplay effect being applied. The effect filters on these tags, so an augment never triggers itself and proc chains stay controlled and efficient.