Tumbley Deer
deer-antar.tech (Couldn't actually make the domain cuz of the whole $9 thing).
Inspiration
Last year we won Best Fun Hack with a physics-based fish flopping game. One hard script, zero explanation needed — people crowded around, laughed, and immediately got it.
This year we wanted to evolve that. We kept asking: what if the fish were back, but this time you were trying to save them? What if you were also a square? What if the floor was ice? That's how Tumbley Deer was born — a square deer on a frictionless ice island, desperately knocking flopping fish into the ocean before they die, while icicles fall from the sky and the whole island tilts under your feet.
The moment we imagined a tiny cube deer tumbling face-first into a wall and flying into the ocean, we knew that was the game.
What It Is
You are a small square deer on a floating ice island. Fish spawn on the ice and start flopping around and dying. You slide into them to knock them into the ocean to save them. You cannot brake. You cannot steer. Every push is a full commitment.
While this is happening:
- Icicles fall from the sky with warning circles projected onto the ice.
- Island Tilt: Each icicle impact tilts the entire island toward the hit point.
- Visual Urgency: Fish flop faster and turn from orange to red as they get closer to dying.
- Unstable Footing: The island bobs and sways constantly because it's floating in an ocean.
How We Built It
Built entirely in Unity 6 with URP in 20 hours.
We engineered a custom physics framework built on top of Unity's PhysX engine, with dynamically adjusted torque driving the core movement system. Rather than traditional character controllers, all locomotion is handled through raw impulse-based force vectors applied directly to a box Rigidbody.
The square geometry means rotational momentum accumulates naturally on every corner impact — the deer tumbles entirely through emergent torque behavior, no animation required. A push cooldown gates every launch as a full kinematic commitment:
$$dt_push = 0.8s => 1.25 decisions/sec$$
For in-air movement correction, we used relative quaternion offsets to dynamically adjust anchor points for mid-air torque application. The idle righting system applies spherical linear interpolation to smoothly resolve the local rotation quaternion back to the upright orientation:
$$q(t) = Slerp(q_curr, q_up, t \cdot w)$$
Gated by a normalized linear velocity threshold — the correction only engages once:
$$v < 0.3 m/s$$
Between pushes, a velocity blending system steers the trajectory by interpolating the current flat velocity direction toward the input vector each frame, preserving momentum magnitude while bending the path:
$$v_steer = normalize(Lerp(v_curr, v_in, a)) \cdot v_flat$$
where $a = 0.06$ keeps steering subtle enough to feel fair without breaking the committed-slide feel.
On wall and surface impacts, a dynamic squish and stretch system linearly interpolates the local scale tensor along the impact normal axis. The deformation magnitude is computed from the collision's relative velocity:
$$squish = 1 - s \cdot clamp((v_imp - v_min) / (v_max - v_min), 0, 1)$$
Fish run an independent coroutine-driven flop loop applying alternating signed torque impulses, with intervals sampled from a uniform distribution that compresses in the final 3 seconds of life:
$$T_flop = U(0.4, 0.9)s$$
Material color is driven by a continuous lerp where $t$ is normalized lifetime:
$$C(t) = Lerp(C_orange, C_red, t)$$
The island runs a sinusoidal idle transform animation for constant ocean bob:
$$y_isl(t) = A \cdot sin(wt + p)$$
On icicle impact, the tilt axis is resolved via a cross product of the impact direction and world up:
$$a_tilt = d_impact \times j_world$$
The rotating wall follows a custom Unity Spline path, with orientation computed from the curve's first derivative:
$$R(t) = LookRotation(dS/dt)$$
Tumbley Deer features a custom URP post-processing pipeline with bloom, color grading, and vignette. All visual feedback — squish on impact, screen shake scaled by collision velocity, and decal warning circles — is procedurally driven with zero hand-keyed animation.
What We Learned
- Physics is Funny: Physics engines create better comedy than manual animation.
- The "One-Hard-Script" Rule: If your core mechanic is interesting and polished, everything else is just decoration.
- Testing: WebGL builds need to be tested early and often.
- Spectacle Matters: A game that is funny to watch is just as important as a game that is fun to play when demoing to judges.
What's Next
Multiple levels with escalating icicle frequency, sound effects for every interaction, and a local leaderboard for fastest all-fish-saved time. The core loop is tight enough to support a lot more content without losing its charm.
Log in or sign up for Devpost to join the conversation.