Project Labyrinth
Welcome to the first dev log for Project Labyrinth, a technical exploration into scalable game architecture, procedural generation, and strategic player agency.
As a developer and educator in the Interactive Multimedia space, my goal with this project is to build a robust C# framework that balances the unpredictability of a “Roguelike” with the deliberate, thoughtful pacing of a tactical RPG.
The Vision: Strategy Over Speed
At the heart of Project Labyrinth is a shift in gameplay philosophy. While many modern RPGs focus on rapid-input combat, this project prioritizes Strategic Patience. This is best exemplified by the Cleric—one of our three playable classes—whose mechanics revolve around area-of-effect “Auras” and positioning rather than “button mashing.”
Technical Pillars
To ensure the project is professional and extensible, I am building around four core pillars:
Hamiltonian Procedural Design: The world is a 5 X 5 grid of 25 rooms. My custom generator calculates a non-overlapping path that forces the player to navigate every single room to reach the end. This ensures a “marathon” experience where resource management is key.
Polymorphic Class Systems: Using C# inheritance and Finite State Machines (FSM), I am developing three distinct archetypes—the Knight (Melee), the Ranger (Ranged), and the Cleric (Strategic)—that all share a core codebase but offer vastly different tactical loops.
State Persistence & The Campfire Hub: Project Labyrinth uses a “Safe Zone” system. Progress is only committed to a JSON-based permanent save when the player reaches a campfire. This creates a high-stakes “Risk vs. Reward” loop.
Data-Driven Content: By leveraging ScriptableObjects, I am decoupling game data (loot tables, enemy stats, NPC dialogue) from the logic, allowing for rapid balancing and iteration.
Development Goals
My primary objective is to build a “Systemic RPG” where player strategy is as important as reflexes.
Player Agency through Archetypes: Providing three unique playstyles, specifically focusing on the Cleric—a class designed for “Strategic Patience” and area-of-effect management rather than rapid-input combat.
High-Stakes Exploration: Creating a “Risk vs. Reward” loop where players must decide whether to push deeper for loot or return to a campfire to “bank” their progress.
Procedural State-Tracking: Solving the challenge of persistence in a randomized world. The system utilizes Seed-Anchored Room IDs to ensure that “Death Chests” and “Elite Guards” can spawn reliably in a newly generated dungeon layout.
Emergent Narrative: Using “NPC Barks” and the “Elite Guard” system to tell the story of the player’s previous failures and current environment through mechanics rather than just cutscenes.
The Feature Roadmap
Over the coming weeks, I will be documenting the iterative development of these systems:
| Phase | Milestone | Focus |
|---|---|---|
| Phase 1 | Structural Foundation | Hamiltonian path generation, 8-way movement, and character prefabs. |
| Phase 2 | The Hub & Persistence | Campfire mechanics, JSON save/load system, and in-world character swapping. |
| Phase 3 | Loot & Narrative UI | Shared inventory, Daily Challenges, and randomized NPC “Barks.” |
| Phase 4 | Combat & The Revenge Loop | IDamageable interface, Elite Enemy modifiers, and the “Death Chest” system. |
| Phase 5 | Polish & Optimization | URP lighting, object pooling, and custom 3D “Showcase” assets. |
“Project Labyrinth is a live demonstration of how modern C# patterns solve complex design challenges, providing a scalable foundation for both developers and students alike.”
The Journey Ahead
Throughout this blog, I will be documenting the technical hurdles and design decisions involved in bringing Project Labyrinth to life. This is more than just a game; it is a case study in how Clean Code and Intentional Design can create immersive, persistent digital worlds.
Stay tuned for Dev Log #2, where I break down the implementation of our character movement and the 2D Blend Tree animation system.
Note: This blog utilizes a combination of original in-engine screenshots and AI-assisted concept art for illustrative purposes. All AI-generated imagery is credited to its respective source and tool.