Overview
Dungeon Delvers is a third-person dungeon crawler in a high-risk-high-reward dungeon environment where the player is a wizard who must survive the dungeon and kill monsters to loot item upgrades with a unique progression system.
The player will go through the dungeons upgrading killing the enemies/boss and acquiring loot to increase their progression. Upon killing the boss the player can go back to the hub and save their gear and progress or continue further to risk it all.
The Challenge
Objective: deliver a polished, high-risk/high-reward dungeon crawler within a strict four-week and testing development cycle.
As the team comprised only four members, the architectural challenge was to build a robust Skill and Attribute System that was modular enough to allow for rapid iteration, yet stable enough to support complex interactions, user feedback and extension.
My primary focus was engineering the core gameplay systems that define the player character (Wizard):
- The Attribute System: Managing state (Health, Mana) and derived stats (Damage Mitigation).
- The Ability System: Implementing three distinct mechanic types (Movement, Offense, Defense).
- The Feedback Loop: Connecting backend logic to the Frontend UI, Animation, and Visual Effects (VFX).
The goal was to create a "feel" that was responsive and impactful, that ensures our high-stakes gameplay loop (survive or lose everything) felt fair.
Implementation & Architecture
The Attribute System
I architected a centralized specific data structure to handle character stats. This went beyond simple variables; it required an event-driven approach to ensure the UI and game state remained in sync.
-
Health & Mana: Implemented as clamped float values with regeneration logic and event broadcasters (observers) that notify the UI when values change.
-
Damage Mitigation: Created a calculation pipeline where incoming damage is intercepted and reduced by the mitigation stat before affecting health. This allowed the Shield ability to dynamically alter the player's durability without changing base health.
The Ability System
To showcase versatility, I implemented three Data Driven abilities spanning different gameplay archetypes using Unity Scriptable Objects. Each required a different technical approach:
Offensive: Fireball (Projectile Logic)
- Logic: Instantiated a physics-based projectile with forward velocity.
- Implementation: Used overlap checks for collision detection upon impact. The system decouples the visual explosion from the logic, ensuring damage is applied even if the particle effect is culled for performance.
- Mana Integration: Checks for available mana resources prior to instantiation; interrupts execution if the resource check fails.
Defensive: Magic Shield (State Modification)
- Logic: A toggle-based or duration-based buff that alters the Damage Mitigation attribute.
- Implementation: When active, this ability hooks into the TakeDamage interface, modifying the incoming integer before the Health reduction logic runs.
- Visuals: Spawns a mesh/particle effect parented to the player transform that rotates to signify active mitigation.
Movement: Blink (Vector Math & Navigation)
- Logic: Instantaneous teleportation to a target location.
- Implementation: This required robust validation to prevent players from clipping out of bounds. I utilized Raycasting and NavMesh sampling to calculate a valid target vector. If the max distance lands inside a wall, the system clamps the position to the nearest valid point on the vector.
Conclusion & Key Takeaways
The Result: Despite the aggressive one-month timeline, "Dungeon Delvers" successfully delivered a functional Core Loop with a full featured combat system (there are a few bugs in there). The Skill System's modular and Data Driven architecture allowed the team to tweak damage numbers, and mana costs without touching code at all, resulting in quick iteration cycles.
Reflecting on the Experience: In previous stages of my career, I might have hard-coded these interactions for speed. However, bringing eight years of experience to this project meant I prioritized scalability and clean architecture from Day 1. By treating the Attribute and Skill systems as distinct but communicating modules, I ensured that if the project were to expand to 50 spells or 100 items, the underlying code would remain stable.
This project represents a year of intensive backend development, demonstrating my ability to architect, build, and deploy complex distributed systems for live-service games.