Sunset Express

A cooperative physics game about carrying an unstable coffin — built for two players, designed to scale to four. Three of us worked on it in Unity for about six weeks in mid-2026, targeting Steam. We stopped in August. The reason matters more than the outcome:

A collection of working mechanics does not necessarily make an engaging game.

The Idea

Four friends run a failing funeral-transport company. The comedy had to come from physics, not written jokes — so the carried object had to behave like another player, not a prop. Four pillars drove it:

• Fair jank — every fall funny and deserved, never arbitrary
• The coffin as the fifth player — shifting centre of mass, sliding corpse, opening lid
• Coordination comedy — obstacles trivial alone, a nightmare together
• Small scope, high polish — prove the carry before building content around it

My Role

I handled game design alongside gameplay and network programming. I owned the coffin physics, the grab / release / break systems, corpse simulation, player controls and camera, carrying and jumping behaviour, and the network architecture. Art, level content and part of the design belonged to the rest of the team.

What Worked

One shared body, two clients. The coffin was never kinematic — real mass, solved from forces applied by two different players, so each carrier felt what the other one did.

A load that moves. Past a tilt threshold the corpse slid and shifted the coffin’s centre of mass. Panic came out of the force balance, not an animation.

Failure you can see coming. Grip loss escalated through readable warning stages. Chaos was acceptable; randomness was not.

Synchronised jumping. Two players jumping together initially broke every grip. The fix was not weaker jumps: inside a short window the break threshold relaxed and the joint stiffened, so the impulse lifted the coffin instead of tearing the connection apart.

Tick-aligned networked physics. I handed Unity’s simulation step to FishNet’s tick loop rather than letting Unity advance physics on its own. Players are client-predicted and reconciled against the server; the coffin is not — it is simulated by the host and replicated, because handing authority to whoever grabs it breaks the moment two people hold it at once. Both halves need the same ordered tick, which is what the pipeline guarantees.

Stage 0 Passed

The prototype had one written gate: two players carrying the coffin in an empty scene for around fifteen minutes and still enjoying it. A feel test, not a bug hunt — the criterion was laughter, and visual polish was excluded from the verdict on purpose.

We tested carrying, rotation, grip tension, break readability, lid and corpse behaviour, and synchronised jumping. The gate passed — the core interaction worked.

What Playtesting Changed

The coffin felt too light. The easy fix was a carrying speed penalty. Instead we moved to a force-limited movement model so its real mass slowed players down. Preserve the design rule instead of masking the symptom.

Corpse ejection was too abrupt. A single frame over the threshold could eject the corpse permanently. We changed it to require the condition to hold continuously. Permanent consequences need readable causes.

The lid would not communicate damage. We had been tuning damage values for a result that could never appear — the hinge spring driving the behaviour was not active. Diagnose the system before tuning its parameters.

Where the Game Broke Down

The problem was not that mechanics failed. It was that we could not convince ourselves they added up.

The prototype passed our feel test, but as the project expanded we grew less confident that the interaction produced enough depth to sustain the game we had planned. We still needed sustained decision-making, variety beyond the novelty of carrying, and a loop players would want to repeat across contracts.

We proved the coffin could be fun to interact with. We did not prove that repeatedly transporting it was enough to sustain a game.

The Ragdoll Pivot

The second lesson was architectural, and it cost more.

With the co-op foundation working, we decided to convert the characters to active ragdolls. The reasoning was sound — if the carried object is force-based, make the characters force-based too. The mistake was assuming compatibility with the architecture holding the game up.

1. Build an active ragdoll rig. Nine runtime classes. The articulated structure never settled deterministically under network reconciliation. Abandoned.
2. Tune the same approach harder. I added a profile asset and a debug harness — expanding the tuning surface instead of questioning the model. Abandoned.
3. Rebuild from a known-good reference. That isolated my own code as the variable. The conflict remained. Development stopped.

Keeping one shared rigidbody in agreement across both machines had taken weeks. Adding dozens of articulated joints was not carrying that constraint — it was drilling through it, three times, each attempt with more code.

Is this feature compatible with the constraint holding the game up?

Why We Stopped

Cancelling was a production decision. Continuing would have meant spending more time expanding content and solving technical problems before we had proven that the underlying loop was worth scaling. We chose to stop rather than keep investing in a foundation we were no longer confident in.

What I Would Do Differently

• Validate the loop, not just the interaction. A good thirty seconds is not evidence of a good twenty minutes.
• Spike the riskiest assumption first. One isolated scene, one question: do two clients produce the same pose after rewind on an articulated body? A no would have cost two days instead of two weeks.
• Separate tuning problems from architectural ones. When repeated parameter changes stop improving behaviour, the model is the suspect.
• Cut the rollback branch before the pivot. Ours was cut once things had already gone sideways.

Technical difficulty and design quality are different problems. We solved hard engineering challenges and still did not have a game worth finishing.

Internal working and repository name: Coffin.