Level Design Studies
Immersive Sim and FPS Level Design
Forthcoming
CONTENT
Content Authoring Pipeline
Developed a tool pipeline for writers and designers to author RPG game content.
Ink-Unity Dialogue Scripting Pipeline
Built a dialogue and scripting pipeline that lets writers author full branching conversations in any text editor, using Inkle’s Ink narrative language, and see them running live in Unity immediately — no engineering handoff required.
Implemented the Ink-to-Unity integration alongside a custom gameplay scripting layer connecting dialogue choices to game state.
Composable gameplay objects
Modular gameplay components (e.x. EntityComponent, GrabbableComponent, InkScriptComponent) let designers author what an object can do entirely in the Unity editor. Each component describes a distinct gameplay verb (e.x. “can be talked to”, “can be picked up”). A designer can compose an object with any functionality, which is then handled by my gameplay engine.
Every component self-registers with backend services, so a writer can query any object’s attributes, inventory, or position directly from Ink — enabling conditional, world-aware dialogue with no per-object engineering work.
The Gameplay Engine
Architected a scalable game backend focusing on SOLID principles.
Dependency Injection Service Backend
I built the entire gameplay backend on service interfaces — every system is accessed through an abstract interface, never a specific implementation. That means real services can be swapped for lightweight stand-ins (a NullInputService, for instance) to run and test any part of the game in isolation. The same pattern that lets writers and designers query any object cleanly is what makes the backend testable and safe to keep extending.
I deemed this architecture choice vital for decoupling and managing the engineering complexity of an RPG.
ServiceLocator.Get<InputService>()
Game State Stack-based FSM architecture
Every gameplay phase and transition — dialogue, pause, cutscenes — runs through one Game Manager class. Built as a stack-based state machine, so any state can suspend what’s running and resume it cleanly.
Enables a scalable game architecture via single-responsibility game manager classes. Critical for dealing with the complexity of an RPG.