Hinges

Hinges is an alternative controller game that uses a real physical door as the main controller.

In the game, you play as the night security guard of a small motel in a remote town. By physically opening, closing the door, and other interactions with the door, you investigate strange rooms and search for the cause of the motel’s unusually high water and electricity bills, as well as the mysterious abnormalities hidden inside the rooms.

Every action you take at the door directly affects what happens in the game, turning simple everyday movements into tense, meaningful decisions.

Role: Lead Engineer

Contributions:

Led engineering production workflow by creating task tracking standards, weekly status reporting, and cross-discipline coordination processes using Jira, Taiga, Discord communication channels, and documentation-driven workflow design
Developed modular gameplay systems by architecting reusable room progression, monster behavior, and event-driven interaction frameworks in Unity using C#, delegates/events, coroutines, and serialized component systems
Integrated core gameplay features by connecting player input, environmental state checks, and monster AI response logic using state-driven architecture, shared managers, and event callbacks in Unity
Improved team collaboration and feature visibility by defining ownership expectations, blocker escalation practices, and completion standards using workflow documentation, task boards, and weekly engineering check-ins
Supported rapid iteration and debugging by building reusable system hooks, validation checks, and modular testing pathways using Unity inspector tooling, debug states, and component-based architecture

Project Information:

Released: May 2026

Duration: 4 Months

Engine: Unity

Platforms: Windows

Language: C#

Tools: Jira, Miro

Team Size: 15

monster base.pdf

Recording 2026-04-29 163743.mp4

Monster Base

Contributed to a modular monster AI framework that drives dynamic horror encounters through aggression scaling, staged positioning, environmental reactions, and jump scare sequencing. My work focused on implementing gameplay state interactions, monster response behaviors, and systems integration between player input, environmental logic, and monster feedback systems.

Core Functionality

Tracks a dynamic aggression meter that increases or decreases based on player behavior and environmental state
Progresses monsters through staged threat levels, updating positioning, animations, and proximity-based audio feedback
Reacts to player interactions including door state, lighting, and knock events
Supports light-based counterplay by temporarily reducing monster aggression when flashed
Randomizes monster positioning within predefined stage locations to create encounter variety
Dynamically scales breathing / response audio intensity based on monster proximity and threat level
Coordinates jumpscare sequencing, animation triggers, audio playback, and fail-state transitions through coroutine-based event flow
Provides a reusable inheritance-based framework for building unique monster variants from shared base systems

My Contributions

Integrated knock-response hooks between player interaction systems and monster feedback behavior
Added monster presence / response checks used to validate contextual knock interactions
Contributed to tutorial support logic that connects player actions to monster/gameplay state systems
Worked on gameplay state validation and cross-system event integration between room, input, and monster systems
Contributed bug fixing, balancing, and gameplay polish across shared monster systems

room manager.pdf

Roommanager tutorial snippet.mp4

Room Manager

Collaborated on a room progression and gameplay flow system in Unity that manages tutorial onboarding, room transitions, player progression, and win-state sequencing. My contributions focused on implementing the interactive tutorial flow, integrating player input systems into progression checks, and supporting room-state logic, event handling, and gameplay polish across shared systems.

Core Functionality

Tracks player interaction state across door input, lighting, and knock mechanics
Validates tutorial completion through multi-step gameplay requirements before progression unlocks
Manages room lifecycle, including initialization, activation/deactivation, and transition sequencing
Handles room-clear progression logic based on player interaction timing and state checks
Coordinates system-wide event callbacks between room, input, lighting, audio, and monster systems
Supports flexible startup states, including tutorial flow and direct gameplay entry via skip logic
Controls endgame progression, final room transitions, and win-state presentation

My Contributions

Implemented tutorial onboarding logic requiring players to use core mechanics (door, light, knock) before advancing
Integrated event-driven callbacks between DoorInput, LightInput, and KnockManager systems for tutorial/state validation
Added skip-tutorial and first-room routing logic for flexible startup flow
Implemented win-state / victory screen progression logic
Contributed bug fixes, gameplay polish, and cross-system debugging on shared room systems

knockmanagerscript.pdf

knockclip.mp4

Knock Manager

Implemented an event-driven interaction system that converts hardware sensor input into in-game responses.

Core functionality:

Receives knock input from an external Arduino sensor or keyboard debug controls
Validates door state before allowing interaction
Enforces cooldown timing to prevent repeated spam events
Dispatches knock events through delegates/event callbacks
Integrates with monster state logic to generate dynamic responses
Includes probabilistic “fake silence” behavior to increase suspense and unpredictability in horror gameplay

My Contributions

Built a reusable event-driven gameplay interaction pipeline
Implemented hardware/software integration between Arduino input and Unity gameplay systems
Designed fallback debug tooling (K input) to enable development before hardware integration was complete
Created contextual response logic that coordinates room state, and monster AI hooks

Engineering Workflow.pdf

Engineering Workflow + Production Pipeline

Designed and implemented a team-wide engineering workflow framework to improve project visibility, communication, and cross-discipline coordination across programming, design, and art teams. Built a structured process for task tracking, ownership, blocker communication, and completion standards to support scalable development practices.

Core functionality:

Tracks engineering work through structured task ownership and status updates in Taiga
Defines required task metadata including summary, engineers involved, designers, and artists for clear ownership mapping
Establishes communication expectations for progress updates, blockers, and coordination needs
Creates cross-team visibility between engineering, design, and art dependencies
Introduces a Definition of Done process for completion clarity and testing accountability
Implements weekly engineering reporting cadence for alignment and early issue detection

My Contributions

Designed engineering production standards by defining task ownership, communication expectations, and completion requirements using Taiga workflow organization, written documentation, and weekly reporting structure
Improved cross-discipline coordination by requiring task-level visibility across engineering, design, and art using shared planning boards, ownership mapping, and early communication practices
Reduced unplanned work and workflow ambiguity by implementing structured tracking requirements and blocker escalation processes using task boards, progress updates, and defined engineering expectations
Created scalable team operating practices by standardizing weekly updates, documentation, and completion criteria using process design, team communication systems, and production workflow guidelines

Post-Mordem:

Working on the core systems for an alternate controller horror game fundamentally changed the way I think about engineering, both technically and as a collaborator within a team. Developing Monster Base, Room Manager, and Knock Manager required me to think beyond isolated feature implementation and instead focus on how multiple gameplay systems communicate, respond to player behavior, and work together to create a cohesive experience. Because the game was built around a physical door controller that translated real-world player actions into in-game events, every system had to be designed around responsiveness, reliability, and immersion. This pushed me to think deeply about how technical systems support atmosphere, pacing, and player emotion rather than simply delivering mechanics.

One of the most valuable technical lessons came from building interconnected gameplay architecture. Systems like Monster Base and Room Manager were not standalone features; they were shared frameworks that influenced progression, environmental reactions, audio feedback, player state, and encounter pacing. Knock Manager added another layer by bridging physical hardware input with digital gameplay logic, converting real-world knocks into meaningful in-game interactions that could trigger state changes, environmental responses, and monster behaviors. Building these systems taught me how important modular architecture is when multiple mechanics depend on one another. It reinforced the value of event-driven design, shared state management, and writing systems that are flexible enough to evolve alongside changing design goals.

This project also taught me that engineering leadership is about creating clarity as much as creating systems. Serving as Lead Engineer meant contributing technically while also helping establish the structure that allowed the team to work effectively. I developed engineering workflow documentation, introduced clear expectations around task ownership and communication, and organized work through Jira-based task management pipelines to improve visibility into progress, blockers, and priorities. Creating standards around how work was tracked, updated, and communicated improved coordination between engineering, design, and art, while helping reduce ambiguity around ownership and feature completion. Through that experience, I learned that strong technical leadership often comes from reducing friction for the rest of the team and building processes that make collaboration easier.

Working on a project built around a physical alternate controller also reinforced how closely engineering and design must work together. Because the door controller was a tangible interaction point, every system connected to it had to feel intentional. A knock could not simply register as input; it needed context, feedback, and consequence within the game world. That challenge taught me to think about engineering systems not just in terms of functionality, but in terms of player experience. Code became a tool for creating tension, anticipation, and immersion, which changed how I think about gameplay programming as a whole.

Most importantly, this project taught me how to balance system design, team coordination, and adaptability during development. Whether building modular gameplay frameworks, integrating unconventional hardware input, or creating engineering workflows that supported a multidisciplinary team, I learned that strong engineering is not just about writing good code. It is about building systems, tools, and processes that allow an entire project to function more effectively. This project strengthened my technical foundation, expanded my leadership skills, and showed me how engineering can shape not only how a game works, but how a team builds it.

Next project

Page updated

Google Sites

Report abuse