Ability Creation Tool
Tech Design
Replayable Survivor Action Roguelike made in a custom engine in which the player obliterates hordes of undead with magic, to grow in power and prevent the Lichgate from opening. However, enemies grow in strength and numbers, as they don’t take kindly to this attempt!
Project Info
Genre: Survivor Roguelike
Project Type: Team
Timeline: 8 Weeks - 2024
Engine: Coral Engine (custom engine)
Platform: Windows & PlayStation 5
Released: Itch.io
Designed & Implemented
- Ability Framework & Combat Component (customizable class/character)
- 4 Different Execution Methods (instant, cast, channel, passive)
- 5 Adjustable Targeting Methods
- Team System & Target Groups (e.g.: friendly, hostile, self, …)
- Customizable Resource System & Cooldown System
- Direct Effects (resource manipulation)
- Over Time Effects (e.g. healing over time)
- Buff/Debuff System (e.g. Damage Amplification, Slow, …)
- Status Effect System (e.g. Stun, Invulnerability, Silence, …)
- Conditional Triggering of Effects (e.g. On Kill, Durational, …)
- Other Supplementary Systems
Overview
Ability System
Abilities are created inside an Ability Database.
Logic, Events, and Character/Class setup are handled by the “Combat Component”, which can be added to actors.
The System comes with 5 Targeting Methods
(e.g. Frontal-Cone, with adjustable range & angle).
Using 1 of 5 Target Filters allows selective application of different ability effects, based on the Teams System.
Users can choose 1 of 4 Execution Methods (e.g.: Casting, Channeling) and define Ability Cooldown, Resource Costs (e.g.: requires 10 mana), and
Interrupt Policies, which all come with various customization options (e.g.: damage based on missing health).
Ability Defaults
Abilities contain basic information such as a Name, Icon, and Description.
They can be executed as instant, cast, channel, or passive.
Additionally, you can define the Cooldown Trigger to “On Use” or “On Duration End”, as well as
add Resource Costs (e.g.: 10% current mana).
Furthermore, Abilities can be given Interrupt Policies (relevant for casting & channeling) through an array.
The System
Combat Component
The Combat Component handles the logic for everything (contains relevant events) and acts as a “hero class container”.
The user can define which Team an actor belongs to, what Resources they have, their quantity, whether it starts full or empty, their base health, armor, and resistance, as well as the Abilities available to the character.
Direct Effect
- Target Resource
- Added or Subtracted
- Value, Type, & Calculation Method
Additional Options:
- Drain (e.g. does damage and heals based on it)
- Value & Mode (equal, percentage, flat)
- Beneficiary (additional target group)
Over-Time Effect
Has the same options as direct effects, but also:
- Name, Icon, Description (allows for tooltips)
- Tick Behavior (is value per tick or overall)
- Duration
- Tick Count (times applied over the duration)
Options & Calculations
When affecting resources (e.g.: health, mana, energy), the user can define whether the value entered is
flat (1:1) or max/current/missing percentage of the targeted resource.
Furthermore, the damage system contains 3 types:
- Physical (reduced by armor attribute)
- Magical (reduced by resistance attribute)
- True (no reductions applied)
Additional Features & Demo Content:
- Customizable Feedback Functions
(e.g.: "Ability is still on Cooldown.")
- Floating Combat Text
- Ability Tooltips on Hover
- Over Time & Buff/Debuff with unique tooltip, icon, etc
- Ability Billboard
//in world Ability Tooltip for showcase
- Basic UI, with Health & Resource Bars
- Class Changer
- Target Dummies & Enemy AI utilizing abilities
- Objective with Gates
//kill all enemies within area;
//gates opening upon completion
Breakdown
What I would change
The tool was intended to be easy to use, packaged in a “plug & play” format.
My ambition for simplicity in regards to usage and increasing the scope as milestones were reached led to the System feeling rigid.
I would focus on creating a strongly modular system, consisting of reusable nodes, splitting different steps to allow for more customization.
I’d stick to the “combat component approach”, but divide events roughly in:
- Availability Check (checking requirements like costs, cooldown, target)
- Preparation Phase (used for anticipation, e.g.: casting a spell)
- Execution (applies costs, cooldown, etc)
//allows for more control over combat functionality (e.g.: gunshot & overlap)
//a function to check target validity would be provided
- Application (application of ability effects)
I would shift the Ability Structure to a multi-layered composition, where individual parts can be added. Some changes I’d like to make would be:
- Conditions (e.g.: “if below 30% health”)
- Effect Composition (e.g.: dealing 15 base damage + 5% current health)
- Scaling & Clamping (e.g.: heal between 10-40, max value at 30% health)
- Ability Charges
- Stacking (e.g.: bleed that stacks up to 5 times)
- Procs & Chances
Effects - General
Each Effect comes with its own set of options/variables.
- Direct Effect (manipulates resource immediately)
- Over-Time Effect (applied recurring)
- Status Effects (e.g.: Stun, Invulnerability)
- Buffs & Debuffs (e.g.: Damage Increase)
- Force (push/pull effects)
A shared key component is the Trigger, which allows the user to define the trigger moment for each Effect:
- On Use (for cast it is upon completion)
- On Hit-Overlap
- Durational (while)
- On Hit (when hitting an enemy in general)
- On Kill
- On Death
- Automatic (passives)
Effect Breakdown
Targeting
The Tool provides 4 Targeting Methods:
Frontal-Cone, Hit-Overlap, Radius around Player (like an aura) or Field (AoE remaining on location).
These check for actors with the combat component, and sort them based on a built-in Team System, before executing the remaining ability logic.
Ability Effects can have 1 of 5 Targeting Filters and apply different effects to different groups:
- Self
- Friendly (same team, includes self)
- Allied (same team, excludes self)
- Hostile (other teams)
- Neutral
Buffs & Debuffs
- Name, Icon, Description
- Duration
- Type: Buff or Debuff (Increase/Decrease)
- Value & Mode (Flat or Base Percentage)
- Buff/Debuff Effects:
- Damage
- Healing Done
- Healing Received
- Armor/Resistance
- Absorb (Prevents receiving Damage or Healing)
- Movement Speed (with UE movement component)
Status Effect
- Duration
- Status Type:
- Stun
- Breakable Stun (breaks when damaged)
- Silence (interrupts & prevents ability usage)
- Kick (like silence but requires an interruptible spell)
- Stagger (only interrupts)
- Root
- Invulnerability
Force
- Push or Pull
- Strength
Post Mortem
Lessons Learned
- Think of a System as a whole rather than one step at a time
- Design Systems with modularity, flexibility, and expansions in mind
- Don’t try to account for everything, but rather focus on what is needed
It is worth stressing the importance of research. For this project, I primarily researched the World of Warcraft Ability Tool, but more importantly, interviewed Developers who created or used similar tools, inquiring about their struggles, tips, and what they liked/disliked about their tools;
Basically, Blood, Sweat, & Tears
You don’t need to reinvent the wheel, and you can learn a lot from developers who have already done something similar.
Ability Effects
In essence, abilities consist of nested structs and arrays, allowing the user to add various effects, with unique Activation Triggers, Targeting Filters, etc.
There are 5 Effects Categories:
- Direct Effect
//immediate resource manipulation, e.g.: heal.
- Over-Time Effects
//like direct effects, but applied over duration
- Buffs/Debuffs
//applied then removed; e.g.: reduced healing received
- Status
//special conditions; e.g.: stun, invulnerability
- Force
//push and pull effects (location displacement)