Overview

As a fan of roguelikes that elevate the genre (Hades, Risk of Rain 2), I wanted to explore procedural level generation and create a combat loop that encourages player decision-making rather than relying purely on randomized power-ups. The core pillars of this project were:

  • A dynamic, procedurally generated dungeon with room-based exploration.

  • A fluid combat system that adapts between movement and attack states.

  • A skill upgrade system tied to executing enemies at the right moment, forcing players to plan their combat encounters carefully rather than just defeating enemies in any order.

Tools & Technologies Used:

  • Engine: Unreal Engine 5

  • Animation & Rigging: Blender (modifying animations to refine movement and combat feel).

Combat & Player Controller

A smooth, responsive combat system was key to making the gameplay feel impactful. I designed a two-state animation system, where the character dynamically transitions between:

  • Movement Mode: Freely roaming the environment, allowing for exploration and enemy positioning.

  • Combat Mode: Triggered when attacking or locking onto enemies, switching the animation set and movement style to feel more controlled and precise, similar to Dark Souls’ lock-on system.

To achieve this, I leveraged UE5’s Animation Blueprint system, adapting and retargeting existing animations while modifying strafing movements in Blender for smoother lateral navigation during combat.

A visual programming blueprint diagram from Unreal Engine depicting nodes for managing mutation abilities. The nodes include operations such as "Pick Mutation Abilities," "Get," "Set," "Remove," "Length," and a function for generating a "Random Integer in Range." The diagram illustrates the logic flow for selecting and updating abilities from a Mutation Abilities List.

Procedural Dungeon System

One of the biggest challenges in roguelikes is ensuring procedural levels remain structured and engaging rather than feeling like randomly stitched-together rooms. To achieve this, I built a Level Manager system that dynamically spawns rooms based on:

  • Predefined room archetypes stored in an actor array (e.g., combat rooms, challenge rooms, boss arenas).

  • Collision checking and adjacency validation to ensure proper placement and avoid dead-ends.

  • A progression logic where players must clear a certain number of rooms before the boss room unlocks, but the exact path remains non-linear, encouraging replayability.

To maintain engagement, the system also randomly assigns enemy compositions and environmental hazards to each room, creating a balance between unpredictability and player adaptability.

Execution-based Upgrade System

Instead of using traditional item drops, I designed a risk-reward upgrade system where new abilities are obtained through executing weakened enemies. Each enemy type offers different potential upgrades, meaning players must:

  • Assess which enemies are worth executing based on their build preferences.

  • Manage their limited execution charges per room, making each decision meaningful.

  • Experiment with different combinations to discover synergies between weapons, abilities, and enemy types.

This system encourages players to think about which enemies they prioritize rather than just eliminating everything in sight. Inspired by Risk of Rain 2’s item drops, this mechanic adds depth by tying progression to player agency rather than pure RNG.