Capstone Project | Unreal Engine 5.5
Third-Person Roguelite Shooter
Role: Gameplay Designer, Technical Designer
Team Size: 6 (Design and Art)
Duration: 4 Months
Platform: PC (itch.io)
Tools: Unreal Engine 5.5, Perforce, Jira, Confluence, Trello
A third-person roguelite shooter built around persistent progression, clear combat feedback, and interactive environments.
Players are intended to fight through wave-based combat encounters across interconnected island levels. Clearing encounters opens a portal to the next area, increasing difficulty and combat intensity.
The game focuses on:
Run-based progression that persists beyond failure
Readable combat feedback in a third-person camera
Environmental systems that create exciting combat moments.
Core gameplay
Design Pillars
Every Run Matters: Failure contributes to long-term player growth
Accessible Depth: Easy to learn, hard to master!
Systemic Environments: Level elements actively influence combat outcomes.
Systems
I created multiple player-facing and systemic features from design through implementation and iteration.
Persistent Progression and Save Systems
I designed and implemented a persistent save/load system for our roguelike gameplay, enabling player character data and progress to carry over across levels.
This is a crucial system because we had to figure out a way to carry over the player's score and the crystal fragments collected. But more importantly, how to carry over all the upgrades the player has chosen. This was done by having the saving and loading code work in the game instance blueprint, having it take the player data from the player blueprint via data structure.
Although this is more back-end work, I believe it is a great example of how technical skills can be important in design work.
I also designed in-game currency where a player can collect and accumulates the more runs the player beats. I made this to create an incentive to keep player retention by rewarding more content and sets long-term goals.
Unlockable Classes
Tank: Survivability-focused with lower mobility.
Mobile/Speed: High mobility speedster with lower durability
I decided to create two classes that are opposed in playstyle. Inspired by RPG disciplines, I made sure to implement buffs and nerfs to specific areas to highlight the strengths of a class.
UI and Player Feedback
Designed and implemented a dynamic player HUD, including:
Ability availability indicators
Dynamic dash gauge
Weapon-responsive crosshair
Solved third-person readability issues by:
Using crosshair state changes to communicate reload timing
Clearly differentiating weapon states without relying on character visuals
Modern shooter games’ solutions heavily inspire the player HUD. The change of crosshair shape when swapping weapon types are taken from games like The Finals and Valorant. Valve’s Deadlock heavily inspires the dash counter and ammo count. I believe this is an excellent way for players to keep track of resources while not diverting their focus to the edges of the display.
Environment Interaction
Implemented destructible environmental systems using Chaos Geometry Collections:
Rocks that explode on impact
Designed and implemented reactive crystal systems:
Area-of-effect damage crystals
Area-of-effect healing crystals
My main idea here was to add a different way for the player to interact with the enemies. I always keep true to design pillars. So, creating the crystals as a level mechanic was a simple addition, yet an effective approach to opening more combat strategies.
Level Design
These are the initial layouts for the levels made during preproduction that act as a draft. But with iteration, we finalised and created a version that better incorporates the purposes of each level.
Designed and built:
Level 1: Onboarding, easy combat pacing, and readability
Level 3: Difficulty escalation and system mastery
3 main factors we kept in mind as a team when creating these levels are:
To support-
Combat flow
Environmental usage
Enemy and Player spawn positions
Player’s first interactions
System Integration and Collaboration
Challenge
Multiple independently developed systems, including combat, buffs, progression, and UI, required reliable referencing in order to have cohesive functionality.
Approach
Held design and technical implementation at the end of sprints
Strictly defined and explained important variables inside blueprints to aid one another when scripting
Used Perforce and Jira to manage merges and reduce conflicts
Debugged Blueprint interactions during system integrations
Playtesting and Iteration
With each playtest, we had to reverify every other system implemented in the game was working properly. When a new mechanic was added that required dependencies from other aspects of the game, we had to carefully test and evaluate before adding it to the final builds of the week to avoid as many problems that might come out to prevent us from further developing and evolving our game.
One of our main concerns was to make sure we reached our intended combat experience as close to what we envisioned in a small amount of time given.
Ensure that each interaction between player and enemy has clear feedback that the player can easily interpret, then have numerous choices to act.
Conducted playtests after:
New mechanics were made
UI updates
Bug fixes