Technical UI Case Study

Debt Deadline

Game UI from concept to Unity: three systems combining interaction design, C#, animation, and sound.

Explore the UI work ↓
Role
Unity Developer
UI/UX · Sound Design
Tools
Timeline
2022 – present
Team
Two-person team

About the Game

A psychological-thriller RPG with a retro-cinematic style, where every playthrough is unique and every decision matters.

Escape a procedurally generated nightmare while managing your sanity—or your own mind will turn against you.

How to keep a complex game readable as its protagonist loses his mind?

Debt Deadline is a roguelike with sanity, combat, and intrigue mechanics. Every system had to read at a glance and feel snappy enough to hold attention between decisions, so I built each one across design, C#, animation, and audio.

Selected UI Work

Making a changing mental state readable through portrait, motion, and sound.

  • Concept
  • UI design
  • C#
  • Animation
  • Audio

David's sanity ranges from −100 to 100 and changes with his decisions. The HUD translates that number into four distinct mental states, so players can read both the current state and the impact of each choice.

The challenge

Sanity changes often, and a bar or a plain number is easy to ignore. Every change had to be felt, and the four mental states had to read without a tutorial.

The approach
  • Four portrait states of David cover the range from −100 to 100, each with its own idle pulse.
  • The sanity star flips from white to black below zero.
  • The number counts to its new value with a flicker.
  • Crossing into a new state fires a star explosion, a hit overlay, and a sound.
  • At −100 the star trembles and the overlay turns critical.
HudView_Sanity.cs
// Runs every frame while the number counts, so one big drop
// can cross two states and play both bursts in order.
bool enteredStrained = isMovingDown
    && previousValue >  SanityThreshold_Strained_Max
    && currentValue  <= SanityThreshold_Strained_Max;

if (enteredStrained)
    OnEnterStrained();   // star flip + hit overlay + FMOD burst
Code example

The displayed number eases toward its target. Every frame, HudView_Sanity checks it against the four state thresholds. The thresholds live in the game's balance constants, so designers retune the states without touching the HUD.

Making every payout feel like a reward against a ticking deadline.

  • C#
  • Animation
  • Audio

With five days to repay the Boss, money is a balance you watch constantly. Rolling digits and synchronized sound give each payout the weight of a tangible reward.

$ 0 0 0 1 2 5 0 6 4 1 2 3 4 5 Iron housing Drum Mask Digit on Digit off
1
Iron housingDark iron frame with the dollar plate. It shakes when money moves.
2
DrumOne drum per digit. Its strip scrolls behind a fixed window.
3
MaskThe window shows one digit. The rest of the strip runs hidden behind the iron.
4
Digit onLit in #ABABFF. These digits carry the amount.
5
Digit offDimmed to #14172E. Leading zeros sit here.
The challenge

Give a constantly monitored resource enough audiovisual weight to make earnings satisfying. The counter needed to feel mechanical while staying readable and responsive. I chose where to simulate real behavior and where a visual shortcut would sell the same effect:

  • FAKEA cheap trick sells the motion, so the trick stays.
  • REALEvery trick breaks the illusion, so the real mechanism goes in.
The approach
  • REALCarry-over. Every drum spins its true distance. 1,250 to 1,480 spins the units drum 230 steps, the tens 23, and the hundreds 2. No fake version looked right.
  • FAKEMotion blur. Above a speed threshold, a drum swaps to a pre-blurred strip.
  • FAKEThe drum. A flat strip scrolls by its UV rectangle. There is no cylinder.
  • FAKETiming. Changes of 100 or less run six times faster.
  • FAKEThe stagger. On a real counter, only carries move the upper drums. Here, each drum starts a moment after its neighbor, a rhythm borrowed from slot machines.
HudView_MoneyCounter.cs
// How far one drum spins, carry-overs included.
// digitIdx: 0 = units, 1 = tens, 2 = hundreds...
private static DigitSpinData GetDigitSpinData(int fromVal, int toVal, int digitIdx)
{
    // Cut off every digit to the right of this drum.
    // For 1,250 → 1,480, the tens drum sees 125 → 148.
    int place = (int)Mathf.Pow(10, digitIdx);
    int fromB = fromVal / place;
    int toB = toVal / place;

    // Each unit of difference is one step of this drum:
    // units 230, tens 23, hundreds 2, thousands 0.
    int dir = toVal > fromVal ? 1 : toVal < fromVal ? -1 : 0;
    int steps = Mathf.Abs(toB - fromB);

    // The drum starts and stops on the last digit of what it sees.
    return new DigitSpinData
    {
        fromDigit = fromB % 10,   // 125 → 5
        toDigit = toB % 10,       // 148 → 8  (5 + 23 steps lands on 8)
        steps = steps,
        direction = dir
    };
}
Code example

HudView_MoneyCounter runs this once per digit. Each CounterDigit then scrolls its strip that many steps along an easing curve, with its own start delay. All timings sit in the Inspector, so I tuned the feel in play mode.

A vintage display cabinet with price tags.

  • UI design
  • C#
  • Navigation
  • Animation
  • Audio

Buying opens the NPC's antique display cabinet; selling presents the player's briefcase with price tags. Both fit the game's noir, retrofuturistic world, while the player-left, NPC-right layout keeps ownership clear throughout the game.

The challenge

Reinforce a narrative game's world through its UI while keeping transactions clear and navigation predictable across mouse, keyboard, and controller.

The approach
  • The cabinet's glass and lighting frame the NPC's goods; price tags turn the familiar inventory briefcase into the player's selling display.
  • Masks, outlines, and dithered textures fake recessed slots, while oversized item art breaks the grid's flat silhouette.
  • One navigation model powers buying, selling, and the player's briefcase, with a different visual skin for each context.
  • Unavailable items turn grayscale; selecting one triggers a wiggle and refusal sound without reaching the transaction logic.