Cherub Online

Nov - Present

Multiplayer Game

Details

Team Name: Solo Project
Role: Programmer
Repo: https://github.com/AlexBuzmion/CherubOnline

Objective

To showcase advanced technical proficiency in game development, C++ efficiency, and Unreal Engine mastery by creating a scalable multiplayer online game using Unreal Engine's source code, integrated with Epic Online Services (EOS) for authentication, data storage, and AWS GameLift/Azure PlayFab for dedicated server hosting on virtual machines.

Tools & Technologies

C++, Unreal Engine, Gameplay Ability System, AWS GameLift, Epic Online Services

Project Summary

Cherub Online is a multiplayer online game designed to showcase scalable systems, advanced technical proficiency in Unreal Engine, and gameplay and network programming with C++. It integrates Epic Online Services for authentication and AWS GameLift for dedicated server solutions. Players can explore a dynamic MMO world with real-time combat, skill systems, and character progression.

Heavily inspired by MOBA and MMORPG games that I personally played, I aimed to create a game that would take the best of those games mechanics, systems and experiences, and make one that I can showcase my skills not only in game development, but also in C++ and Unreal Engine.

My Contributions:

1. Core Gameplay Ability System (GAS)

From the start, I knew combat would be the heart of Cherub Online. Whether players engage in PvE or PvP, the combat system had to feel polished, responsive, and rewarding. To achieve this, I designed and implemented the core Gameplay Ability System (GAS) and the supporting attributes, enabling dynamic skill types and interactions.

Tag-Driven Player States The modularity of Gameplay Tags was key. Tags like `IsAlive`, `IsCasting`, or `IsAttacking` were used as lightweight, network-efficient markers to control player states. This approach made it simple to manage conditions such as:

Whether a player can move.
If they can attack or cast abilities.
When certain buffs or debuffs apply.

Building Abilities To streamline ability creation, I extended the GameplayAbility class to include reusable variables like cost and cooldown, as well as a player reference by default. This saved time and made abilities easier to manage. Normally, GAS requires separate GameplayAbility, GameplayEffect, and GameplayCue for each skill. To simplify this:

#include "CoreMinimal.h"
#include "Abilities/GameplayAbility.h"
#include "CherubGameplayAbility.generated.h"

UCLASS()
...

Cost Management: I created just two GameplayEffects (one for stamina and one for mana). A custom magnitude calculation retrieves the ability's cost and applies it to subtract the appropriate resource when a skill is used.
Cooldown Management: A similar setup applies cooldowns dynamically, ensuring consistent logic across abilities.

float UBaseCostCalcuation::CalculateBaseMagnitude_Implementation(const FGameplayEffectSpec& Spec) const {
	const UCherubGameplayAbility* Ability = Cast<UCherubGameplayAbility>(Spec.GetContext().GetAbility());

	if (!Ability) {
		return 0.1f; 
...

Modularity was one of the things I kept in mind during the system design. For instance:

HUD Slots: Each 'Hotbar Skill' slot can hold a reference to a BaseAbility UObject, which I built to store all ability details (e.g., name, description, cost, cooldown, targeting type, VFX references, etc.). This system future-proofs the game for easy addition of new skills.
Skill Flow: When a player presses a hotkey (1-0), the slot identifies the skill type - Self-Cast: Directly triggers a Server RPC to execute the ability; Ground Targeting: Activates a `GameplayAbility_GroundTargeting` class that waits for the player to select a target area; Actor Targeting: Runs a `GameplayAbility_ActorTargeting` class that awaits a valid target from the player click
Once validated, the ability: Commits the cost and cooldown using the shared GameplayEffects, applies effects to the target (e.g., damage, buffs, debuffs), and executes GameplayCues to spawn VFX on the appropriate clients.

Why This Approach? The sequential nature of events within GAS made it an ideal fit. By decoupling ability logic from the core game and relying on replicated properties and server-side validation:

I ensured fair play in a multiplayer environment.
Players can’t exploit or bypass critical game mechanics.
The system remains modular, scalable, and easy to extend with future content.

2. Attributes System

Of course, the Gameplay Ability System's main purpose is to manage and modify attributes seamlessly. Attributes like health, mana, and various combat-related stats (e.g., attack, defense, and magic power) are the backbone of player progression and gameplay mechanics. To achieve this, I designed the Basic Attributes System to integrate tightly with the Gameplay Ability System (GAS) while maintaining modularity, scalability, and network efficiency.

3. MouseTrace and TargetActor

Precision targeting is a vital aspect of skill-based combat. Whether selecting an enemy, marking a ground location, or canceling an action, the MouseTrace TargetActor is a class inherited from the AGameplayAbilityTargetActor. This system provides players with the ability to preview their actions, confirm or cancel their choices, and interact seamlessly with the game world—all before committing to an ability.

Key Learnings:

Demonstrated Object-Oriented Programming principles like inheritance and polymorphism, with a BaseCharacter class inherited by PlayerCharacter and EnemyCharacter.
Designed reusable base components and systems to ensure flexibility and scalability in the codebase.
Integrated Unreal Engine's Gameplay Ability System (GAS) to manage dynamic skills and ensure server-side validation.
Built a server-authoritative architecture with AWS GameLift for scalable dedicated servers and future sharding.
Designed a modular Basic Attribute System with replication to handle health, mana, and leveling.
Developed a Hotbar System to allow real-time skill customization and visual feedback for players.
Implemented a mouse-trace targeting system for ground-targeted and actor-targeted abilities.
Created a data-driven system using tables for experience progression, skill attributes, and cooldowns.
Focused on combat and AI systems with dynamic abilities and NPC threat assessment.
Incorporated robust error handling and debugging tools to improve server-client communication.
Enhanced player experience with immersive visual and audio feedback systems.
Adopted Agile practices for iterative development, prioritizing core features and testing frequently.

Learn more about me 👇🏼