← RETURNCASE FILEGameSTATUS: ONGOING2026.07 – Present
RT-FU-006

For U

#006

A six-stage first-person experience on what algorithmic feeds leave behind. The reward lasts seconds; the debt comes back as emptiness. Most anti-addiction work casts you as the victim — this one makes you the accomplice.

Année
2026-ongoing
date
2026.07 – Present
dimension
1920×1080
media
Unity / C# / MCP-assisted development
role
Solo concept-to-production designer & technical artist

A — THE SIX STAGES

Stage
Metaphor
Mechanic
01Primal desire
The origin of pleasure
A hand reaches for a banana. Grasp, release, no friction.
02Blind faith
Nietzsche — the death of God
In a prayer scene, the sacred object melts.
03Sisyphus loop
Camus — the absurd
A stone on a closed path. Letting go is a way out.
04Burnout society
Han — self-exploitation
Keystrokes pile up office text until the room collapses.
05Algorithmic feed
Han — hyperattention
A corridor drains to monochrome, then to silence.
06Data reckoning
Sartre — the accomplice
Your own behavioural trace, hung in the scene as data.

Stage 6 only works if the data is real. The first build looked finished and was fed by a random number generator — placebo data, at the climax of a work about confronting an authentic trace of yourself. I rewired it to read the actual interaction frequencies from the first five stages.

B — THE LEVEL IS THE LOOP

Stage 3 is Sisyphus: a stone on a closed path, where letting go is the only way out. The easy build is a straight corridor that teleports you back to the start. Instead the track is an actual Möbius strip, generated at runtime from its parametric equation.

public static Vector3 GetMobiusPoint(float u, float v, float R)
{
    float r = R + v * Mathf.Cos(u * 0.5f);          // radius wobbles as the band twists
    return new Vector3(r * Mathf.Cos(u),
                       v * Mathf.Sin(u * 0.5f),     // the half-angle is the twist
                       r * Mathf.Sin(u));
}

240 segments around the ring by 8 across the band — 2,169 vertices, 3,840 triangles, rebuilt whenever a parameter changes.

Two things only surface once you actually build one:

Consequence
Why
Fix
Half the track renders invisible
A Möbius strip has one side, so backface culling removes the surface you are standing on for half the loop.
The generator forces _RenderFace = Both and enables the _DOUBLE_SIDED_ON keyword on its own material.
The stone can't be moved in world space
There is no consistent "forward" on a non-orientable surface.
GetMobiusPoint is public and static, so the stone is positioned in parameter space instead — it travels along u.

Push u from 0 to 2π and the stone arrives back where it started, on the other face. The loop isn’t scripted or triggered. It’s the geometry. OnValidate() regenerates the mesh live in the Scene view, so the ring can be re-proportioned without entering Play mode.

C — HOW IT’S PUT TOGETHER

Sixty-one C# scripts across eight domain-scoped folders — one per stage, plus _Core and UI_Dialogue. Nothing is grouped by type, so a stage can be opened, changed or broken without touching any other stage.

Folder
Scripts
 
Stage4_Office
11
keystrokes, collapse
Stage3_Sisyphus
9
Möbius geometry, stone, camera
_Core
8
event bus, shared services
UI_Dialogue
8
dialogue, HUD
Stage2_Faith
8
melt, fracture
Stage1_Primal
6
grasp and release
Stage5_Feed
6
drain to monochrome
Stage6_Future
5
behavioural trace

Stages talk to each other through a static event bus rather than direct references — a stage raises SceneComplete and doesn’t know or care what is listening.

The restructure happened partway through, with the project already in a playable state. It was done through Unity’s own asset database rather than by moving files in Finder, so every GUID and .meta file survived and no prefab, scene or material reference broke.

D — ONE MATERIAL, SIX STAGES

The corridor walls are a live video feed. Its decay across the stages — the warp, the speed trails, the glitch, the drain to silence — is not six sets of authored assets. It is one shader with seventeen exposed floats, ramped over the course of the stage.

Nine effects stack inside a single pass, each gated on its own parameter:

Layer
What it does
Cost
Jelly (vertex)
Two crossed sine products displace XY in object space, so the wall breathes rather than sitting flat.
Vertex only
Oil smear arc
Polar warp — angle from atan2, radius from length, then an arc offset of sin(angle * 3 + r * 10 − t) pushes the UV outward along its own bearing.
UV math
Wave warp
Two crossed sines on the sampling UV.
UV math
Vortex shear
A 2D rotation whose angle grows with distance from centre, so the middle holds and the edges twist.
UV math
Slice shift
Eight horizontal bands from floor(uv.y * 8); each band gets a hashed horizontal offset that re-rolls eight times a second.
UV math
Glitch blocks
UV quantised to a grid that coarsens as intensity rises — 180 blocks down to 20 — so the picture doesn't just break, it gets blockier.
UV math
Radial speed trails
Ten taps accumulated along the vector from screen centre, averaged. The one layer that actually buys its effect with bandwidth.
10 samples
RGB chromatic shift
Three taps, R and B offset in opposite directions.
3 samples
Border melt
Edge distance through a smoothstep, blended against a channel-rotated copy of itself (col.gbr) so the frame bleeds inward.
Free

Six of the nine are pure UV arithmetic — they rearrange where the texture is read from rather than reading it more times. Only the trails and the chromatic shift add taps, and they sit in opposite branches of the same if, so they never run together.

Every layer is an if (_Parameter > 0.01) away from costing nothing at all. A stage that doesn’t want the vortex pays for one comparison. That is what makes ramping the whole set from a timeline affordable, and it is why the escalation could be tuned by dragging sliders instead of rebuilding scenes.

E — SEE IT IN ACTION

The full walkthrough, all six stages end to end.