All showcases on this page are just a brief overview of the systems, capturing their essence but not their entirety.
If you would be interested in diving deeper or have any inquiries, I'd be delighted to elaborate further.
Ability System
Implemented inside ELVERA project
ELVERA's Ability System is anchored by a central base class named Ability_Base. This class stores the core data and functions for every ability in the game, establishing the foundation for a multi-tiered inheritance.
Through a structured approach, it ensures efficient management and consistent behavior across all abilities. Beyond its foundational framework, the system offers overridable functions, facilitating tailored behaviors for each ability. Integrated elements such as input bindings, activation logic, and multiplayer compatibility using Unreal Engine's replication make it a comprehensive and dynamic system.
Design Approach
The system is neatly categorized into three distinct ability types: Primary, Secondary, and Ultimate. Each type is a derivative of the Ability_Base, preserving common data and logic while allowing for child-specific functionality.
Core data
Central to the system is the Ability_Info structure.
It captures core parameters for abilities: name, icon, category, cooldown, cast conditions, weapon requirements, animations, and a suite of behavior flags (booleans), dictating contexts and constraints for ability usage
Overridable Functions
The system provides flexibility with functions in the base class that can be overridden by child classes, enabling tailored logic or entirely new behaviors for each children.
Ability
Association
Every in-game character is equipped with a set of three abilities - one from each type.
These children, affiliated with their respective types, ultimately trace back to the foundational Ability_Base. Such a layered approach facilitates both global control at the base level and nuanced adjustments in specialized subclasses.
Ability Assignment Mechanism
Base character class has designated slots to bind specific abilities. Upon assignment, an integrated logic extracts and utilizes this ability data across various game systems - from tooltips and cooldown indicators to sound cues and gameplay mechanics.
Cleanup Mechanisms
Every ability has a customized ForceEverythingAbilityRelated
Destruction() function.
This function is designed to clear any leftovers an ability might leave in the game world. Its core use is usually between rounds to ensure a fresh start, devoid of any lingering ability artifacts from previous rounds.
Multiplayer Compatibility
The entire architecture is synergized with Unreal Engine's replication system. This ensures that all players receive real-time, synchronized ability data, making sure to provide smooth multiplayer experience.
Input Bindings
In ELVERA's base character class, three distinct input actions are dedicated for abilities: Primary, Secondary, and Ultimate. Each ability is linked to its unique data asset input action. These actions are then mapped to a data asset input mapping context, initialized in the player controller once the player connects.
Activation Process
Each ability type is bound to a specific key on the player's keyboard. When activated, first, a series of conditions are checked locally to ensure the ability's valid use.
Then, using server RPC, additional verifications happen to make sure that there's no attempt to bypass the system and that server agrees with a client. Once cleared, an actor is spawned at the player's current location. It's essential to note that this actor isn't a tangible entity in the game world but serves as a logic carrier for the ability.
Ability Logic Execution
On actor spawn, specific abilities (for example JumpPad) will initiate their corresponding logic.
For the JumpPad, it would involve spawning the static mesh representing it, setting up its collision overlaps, defining its behavior (like launching players once overlapped), its accessibility (allies or enemies), and its duration of existence in the game world. All of this is then also accompanied with things such as sound cues and elements that enhances the ability.
Attack System
Implemented inside ELVERA project
ELVERA's Attack System is an intricate yet modular system I designed to manage and execute character's basic attacks.
Grounded in a combo-based design philosophy, it allows characters to perform a sequence of attacks with different weapons. It seamlessly integrates with the game's character stats, items, and other systems to ensure dynamic gameplay, responsive mechanics, and visually appealing aspects.
Design Approach
My design philosophy stresses seamless integration and modular design.
To that end, the entire melee and ranged attack logic is encapsulated within a dedicated Basic Attack Component.
This component can be attached to the base character class, ensuring that every character inherits its combat capabilities. This component-centric approach makes the system flexible, scalable, and easy to debug or extend.
Animation Integration
Recognizing the combo counter and weapon type, the system selects the fitting attack animation.
Dynamic animation slots are linked to specific portions of the player's skeleton, enabling concurrent movements like attacking while running or jumping.
Melee Mechanism
An integral part of the melee combat mechanism is a dynamic collision box attached to each character.
In its default state, the collision box assumes the character's position.
Upon the player's first attack, this system pulls all vital information like attack speed, range, AoE, and other necessary character stats. It then computes to adjust the collision box's location, dimensions, and orientation for melee attacks. The direction it faces is determined by the player's input and location, ensuring accurate and responsive combat interactions.
Foundation
This system's core is a combo based mechanism tracking the sequence of attacks and resetting accordingly.
It's further enriched by the enumerator which tracks and classifies equipped weapons for correct execution logic—differentiating between one-handed weapons, two-handed weapons, bows, dual blades, and even unarmed combat.
Core Data
The system's heartbeats with its well-defined data structures. The character parameters comprise fundamental details like attack speed, attack damage, attack range, and even the attack's area of effect. There are also several additional variables that may affect each attack accordingly.
Damage Processing
After hit detection, the system evaluates damage, type, and associated attributes, used to then feed into other in-game systems, such as UI (Kill Tracker, Healthbar, Damage 'Pop' and more...)
Audio-Visual Augmentation
Integrated sound and visual cues, including animations and particle effects, amplify each attack for a more exciting combat experience.
Multiplayer Compatibility
To guarantee seamless multiplayer experience, the system replicates essential data across clients, offering fluid and synchronized combat actions.
Validation Process
There are several local checks that run to do preliminary validations ensuring the attack conditions are met.
Upon passing local verifications, a server RPC lends another layer of validations to ensure no mismatch or cheating is at place.
Ranged Mechanism
For the ranged combat mechanism, the logic uses a Line Trace by channel mechanism for precise hit detection.
The core of this system involves determining a direction vector by subtracting the camera's location from the targeted location. This vector, once normalized to a unit length, gets scaled according to the weapon's specified range. The result of this process defines the line trace's endpoint, achieved by adding the resultant extended vector to the camera's location. This ensures precise hit detection, adapting to various ranged weapons and their distinct parameters.
Inter-system Cohesion
The Attack System collaborates seamlessly with the character's stats, items, weapons, enchants and other game mechanics.
Interaction System
Implemented inside ELVERA project
ELVERA's Interaction System was designed to simplify and unify player interactions within the game world.
At its core is the Interactable Actor interface, serving as a universal foundation for most of the interactions. This approach ensures streamlined gameplay, lessens redundant logic, and provides players with an intuitive mechanism tied to specific keyboard inputs.
Design Approach
At the heart of the Interaction System lies an interface named Interactable Actor. This core interface is equipped with functions that track the interaction types, verify if the actor is within an interaction range, manages the interaction process, and facilitate the cancellation and successful completion of interactions.
Interaction Process
Once a player presses the mapped keyboard key to start interacting, a server RPC checks the overlapping interactable actor for the presence of the Interactable Interface before invoking the OnInteract() function. The general shared logic for this interface function is defined within the base class itself, however, all children are free to override this logic to accommodate their needs.
Checks
The system has several checks in place, such as the allowed team/s, player's current interaction state, interactable actor's current state and others.
Base Class
Any actor primed for interaction should inherit from the InteractableActor_Base class. This base class goes hand in hand with the interface, enabling it use its functions and data accordingly.
It also holds the very important struct called InteractableActor_Info that holds information about the interactable actor such as its name, distance for above head widget visibility, interaction range, interaction type, base interaction time, interaction tick frequency and more.
Interactive actors
Interactive actors are characterized by a specific interaction radius. These actors maintain information concerning all players and objects that fall within this designated interaction area.
In-game specific interactions
The game contains a plethora of interactions, ranging from sabotage of certain objects and their repair tasks to other interactable elements across the game's map.
Multiplayer Compatibility
To guarantee seamless multiplayer experience, the system replicates essential data across clients, offering fluid and synchronized combat actions.
Post Interaction
Upon successful finish of an interaction, the system calls the HandleSuccessfulInteraction() function. This function handles many things, such as clearance of timer handle, resetting all values that was previously set to accommodate the interaction process, removes any UI elements and more.
While this function possesses a general logic suitable for all interactive actors, it can once again be overwritten for each child if desired.
Start of Interaction
Once the OnInteract() function gets called and all checks get passed successully, the HandleStartInteraction() function comes into play.
This function sets an array of parameters, including identifying the interacting character, updating the interaction status, and creating relevant UI elements, such as interaction widget.
Types of Interaction
The system has two principal types of interaction: Instant and Progressive.
The first type speaks for itself. Once the player starts the interaction, it also finishes immediately after.
The latter, a prolonged interaction, though, requires players to hold a interaction key for a certain amount of time to finish the interaction and is susceptible to interruptions such as player getting crowd controlled, dying, being displaced from the interaction range in some way or simply cancelling the interaction by releasing the button prematurely.
Buffs & CC System
Implemented inside ELVERA project
ELVERA's Buffs & CC System is a essentially comprehensive component attached to character base class, designed to manage and apply various buffs, debuffs, and crowd control effects.
This system integrates seamlessly with the character's statistics structure, ensuring that buffs/debuffs and CC can dynamically modify a player's stats and states during gameplay. Through unique identifiers and well-organized tracking arrays, the system ensures efficient application and removal of effects without overriding or clashing.
Design Approach
For this one, I went a bit off-standard. It uses a unique dual-purpose design which allows buffs to take on positive or negative values, serving as buffs or debuffs respectively.
This approach ensures clarity and reduces the complexities often associated with distinguishing between the two.
Additionally, this system is also tied closely with the CC management, that is being handled in a very similar way.
Buff Tracking and Removal
An internal array called Buffs, provides the backbone for buff management as mentioned above. In addition to that, there are several functions called 'recalculators' that use the information from the array and update the character's stats accordingly.
Since each array entry also stores the globally guide identification (GUID), it enables efficient tracking and precise removal of buffs when needed.
This can be then used to call the RemoveBuff() function that handles the removal of the buff.
Character Stat Structure
This system works in tandem the character stats structure that is present in the base character class.
Divided into base and bonus stats, it ensures a clear distinction between static attributes (influenced by weapons) and dynamic attributes that respond to gameplay elements like buffs and debuffs.
Buff Application Logic
The component contains several functions, but the most notable is the ApplyBuff() function. Using this one ensures we can add buffs by recognizing parameters like buff type, value, and its source. According to those input parameters, struct entry with all the info gets created inside of the dedicated array that holds all the active buffs.
Crowd Control Mechanism
Drawing inspiration from the buff management, the crowd control mechanism also uses 'apply' and 'remove' functions, explicitly ApplyCC() and RemoveCC().
Dedicated enum enable the system to differentiate various crowd control types, enriching the diversity. This not only interfaces seamlessly with the game's stats framework but also incorporates the state structure that is located inside of the base character class.
This structure captures the current conditions of players using flags/booleans, tracking actions and statuses like IsMoving, IsRotating, IsInAir, IsCasting, IsAnchored, IsInteracting, IsInvisible, and IsDead.
Simultaneous Crowd Control Effects
The game can layer multiple crowd control effects on characters, such as stuns, roots, and silences. The system's architecture guarantees no overriding, allowing simultaneous effects that don't interfere with each other.
The same applies to the buffs system, where one player can have dozens of buffs applied at the same time without any problem.
Universal Application
The Buffs and CC system is very versatile. Beyond abilities, other game elements, such as weapons, enchants and other aspects can also apply buffs/debuffs or crowd control, showcasing the system's adaptability and comprehensive nature.
Multiplayer Compatibility
To guarantee seamless multiplayer experience, the system replicates essential data across clients, offering fluid and synchronized combat actions.
Character Selection
Implemented inside ELVERA project
While I was development the Character Selection System for ELVERA, my main goal was to ensure a seamless, fair, and strategic introduction to the game. Drawing inspiration from notable games like League of Legends, I aimed for a streamlined yet comprehensive experience.
A crucial element is the connection verification, essential for a synchronized game start, eliminating discrepancies. Each player is systematically assigned an order index and team upon server travel to the character selection (from lobby), enabling a turn-based selection process.
As characters are chosen, they become unavailable for others, emphasizing uniqueness in gameplay roles.
A highlight is its adaptability, capable of accommodating varied team sizes, from 1v1 matches to larger 3v3 showdowns - it all automatically adapts to the amount of players travelling from the Lobby.
This demo video is a bit outdated and significant improvements have been implemented recently. New one will be uploaded soon!
Design Approach
For this was, League of Legends was a core inspiration with a primary goal of facilitating strategic decisions, promoting teamwork, and providing a seamless transition from lobby to the actual gameplay.
The system prioritizes user experience, ensuring players have enough time and information to make informed decisions while also being adaptable to various match scenarios and their team's composition.
Character Availability Tracking
As characters are chosen, they're marked unavailable in real-time. This avoids duplicate picks, ensuring diversity in gameplay roles.
Dedicated Selection Environment
A separate level, which includes its unique game state, game mode, player controller, and player state, for an undistracted character selection experience.
Dynamic Character Preview
Before and after making a selection, players can preview characters and their capabilities, understanding their abilities. This aids especially new players to make informed decisions.
Connection Verification & Synchronization
Timer mechanism is present under the hood to verify all player connections from the lobby. This ensures every player is on the same page before the game starts. No more unfair matches!
Adaptive Timers for Selection
A dynamic timer system indicating the time left for each player's selection, including text and progress bar cues that are integrated to avoid any unnecessary 'dodge' situations.
Penalty Mechanisms
If a player doesn't make a selection within the selection time, the session is canceled to avoid gameplay disadvantages for either team.
This player also faces a penalty in a form of rating subtraction. If the 'naughty' player is the listen-server/host, the penalty is doubled.
Integrated Chat System
While not covered in detail here (since it's a broad system), the character selection level incorporates a chat system (team and all mode) for player communication.
Multiplayer Compatibility
To guarantee seamless multiplayer experience, the system replicates essential data across clients, offering fluid and synchronized combat actions.
Modularity and Adaptability
The system dynamically adapts to different player counts, ranging from 1v1 to 3v3 scenarios. Everything is designed to be dynamic and not hardcoded - we don't like that!
Comprehensive Player Data Struct
There is a PlayerInfo_CharacterSelection
structure located in the player state.
This stores information like assigned pick index, team, selected character, and other crucial details which are then used for gameplay initialization upon travel to the gameplay level.