cd ..
Unity Team 6 Platformer Jam #2

Shrunk Paws

A one-week jam precision platformer: chase your shrinking dog through a giant laboratory before it vanishes below atomic scale.

cover.png
Shrunk Paws cover art
features.idx (7 features)
  1. overview
  2. what_i_did
  3. features/
  4. 01Multi-Layer Clamped Parallax Engine
  5. 02Precision Speedrun Timer System
  6. 03Menu Flow & Scene Transition Architecture
  7. 04Custom Unity Editor Tooling
  8. 05Kinematic Platformer Controller & Movement Tuning
  9. 06Reactive Physics Hazards & Traps
  10. 072D Pixel Art & Environment Design
  11. gallery/

Project overview

Shrunk Paws is a fast-paced 2D precision platformer and companion chase speedrunner created in Unity 6 for Platformer Jam #2. When a brilliant scientist's experimental shrinking potion is accidentally ingested by his playful dog, the panicked pet shrinks and sprints away into the laboratory.

To save his companion, the scientist consumes the potion and embarks on a frantic chase across a world where everyday lab equipment has become giant and deadly. Players must sprint, double-jump, wall-slide, and air-dash across rapidly shifting scales of reality, avoiding falling hazards and maintaining pace with the autonomous dog. If the dog stays off-screen for more than 10 seconds, it shrinks so much that it becomes smaller than atoms and dies, losing the chase forever.

Built under tight one-week jam constraints, the project achieved a polished, highly responsive gameplay feel supported by speedrun timing tools, multi-layered parallax depth, and handcrafted retro pixel art.

What I did

As Gameplay Programmer, Pixel Art Artist, and Co-Game Designer in a 6-person team, I contributed extensively to both technical systems and artistic production during the 1-week game jam.

I engineered the multi-depth mathematical parallax background engine (Parallax.cs, CameraParallax.cs) with clamped depth normalization and seamless infinite wrapping across the macroscopic laboratory stage. I implemented the high-precision millisecond speedrun timer (GameTimer.cs) with monospaced TextMeshPro rendering and PlayerPrefs record persistence.

I architected the UI navigation and scene transition pipeline (MainMenu.cs, PauseMenu.cs, SceneTransition.cs, CreditsUIBuilder.cs), built custom Unity Editor QA tooling (PlayerPrefsResetter.cs), co-engineered the 2D kinematic platformer controller (PlayerController.cs), co-programmed reactive physics hazards (falling potions, toxic gas clouds, rolling test tubes), and authored pixel art sprites, tilesets with autotiling, and animations, full-screen illustration excluded.

Team project · Gameplay Programmer, Pixel Art Artist (also Co-Game Designer)

Features I implemented

01

Multi-Layer Clamped Parallax Engine

I engineered a mathematical camera-relative parallax scrolling system (Parallax.cs, CameraParallax.cs) that creates convincing 2.5D depth across the game's level.

The system calculates each layer's parallax factor based on its Z-distance relative to the subject and camera planes. Positive Z depths are normalized against the camera far clip plane using Mathf.Clamp01 (preventing distant objects from moving faster than the camera), while negative Z depths generate foreground parallax. Seamless infinite wrapping recalculates start positions as the camera moves past sprite bounds, avoiding visual popping or clipping.

In-editor view of the multi-layered parallax effect used in the game
Multi-layered depth parallax in the Unity Editor
csharp
float parallaxEffect
    {
        get
        {
            if (distanceFromSubject > 0)
            {
                // Find the absolute World Z of the far plane
                float farPlaneWorldZ = cam.transform.position.z + cam.farClipPlane;

                // Find the relative distance from the subject to that far plane
                float distanceToFarPlane = farPlaneWorldZ - subject.position.z;

                // Divide and Clamp. (Clamp01 strictly prevents the value from going over 1.0, which stops far objects from moving faster than the camera).
                return distanceToFarPlane > 0 ? Mathf.Clamp01(distanceFromSubject / distanceToFarPlane) : 0;
            }
            else
            {
                // Find the absolute World Z of the near plane
                float nearPlaneWorldZ = cam.transform.position.z + cam.nearClipPlane;

                // Find the relative distance from the near plane to the subject
                float distanceToNearPlane = subject.position.z - nearPlaneWorldZ;

                // Divide. (distanceFromSubject is negative, so this correctly returns a negative parallax effect, making foregrounds zip past the camera).
                return distanceToNearPlane > 0 ? (distanceFromSubject / distanceToNearPlane) : 0;
            }
        }
    }

    private void FixedUpdate()
    {
        // 0 == move with player || 1 == completely stationary background || negative == fast foreground
        float distance = cam.transform.position.x * parallaxEffect;
        float movement = cam.transform.position.x * (1 - parallaxEffect);

        transform.position = new Vector3(startPos + distance, transform.position.y, transform.position.z);

        if (movement > startPos + length)
        {
            startPos += length;
        }
        else if (movement < startPos - length)
        {
            startPos -= length;
        }
    }
}
Mathematical depth ratio calculation and wrapping in Parallax.cs
02

Precision Speedrun Timer System

To encourage speedrunning competition in the jam community, I built a high-precision timer (GameTimer.cs) measuring elapsed time down to individual milliseconds.

The timer uses monospaced font spacing in TextMeshPro to prevent horizontal digit jitter during high-frequency frame updates. Personal best run times are tracked and persisted across game sessions via Unity's PlayerPrefs, surfacing on both the HUD and the main menu screen.

In-editor speedrun timer showing millisecond precision and personal best records
Millisecond-precision speedrun timer with monospaced TextMeshPro formatting
csharp
private void Update()
    {
        if (!m_running) return;

        m_elapsed += Time.deltaTime;

        if (m_showMilliseconds)
        {
            // If we want milliseconds, we MUST update the UI every frame.
            UpdateLabel();
        }
        else
        {
            int currentSecond = Mathf.FloorToInt(m_elapsed);
            if (currentSecond != m_lastShownSecond)
            {
                m_lastShownSecond = currentSecond;
                UpdateLabel();
            }
        }
    }
High-frequency frame timer update in GameTimer.cs
04

Custom Unity Editor Tooling

During the intense 7-day jam development cycle, rapid testing of speedrun records and settings was critical. I created custom Unity Editor extensions (PlayerPrefsResetter.cs) adding dedicated menu shortcuts to the editor top bar.

The tool exposed one-click commands (Tools -> Reset Best Time and Tools -> Clear ALL PlayerPrefs), enabling programmers and designers to test first-time user flows and record persistence without manual registry editing.

Unity Editor top menu bar showing custom PlayerPrefs reset tools
Custom Unity Editor menu extensions for rapid speedrun data resets
csharp
using UnityEngine;
using UnityEditor;

public class PlayerPrefsResetter
{
    // Creates a button at the very top of your Unity screen: Tools -> Reset Best Time
    [MenuItem("Tools/Reset Best Time")]
    public static void ResetBestTime()
    {
        PlayerPrefs.DeleteKey("BestTime");
        Debug.Log("TESTING: "BestTime" has been deleted from PlayerPrefs!");
    }

    // Creates a second button to wipe EVERYTHING (Last run, best run, volume settings, etc.)
    [MenuItem("Tools/Clear ALL PlayerPrefs")]
    public static void ClearAll()
    {
        PlayerPrefs.DeleteAll();
        Debug.Log("TESTING: ALL PlayerPrefs have been completely wiped!");
    }
}
Editor menu commands in PlayerPrefsResetter.cs
05

Kinematic Platformer Controller & Movement Tuning

I collaborated on engineering the responsive 2D character controller (PlayerController.cs). Built around Rigidbody2D velocity smoothing, it incorporates key platformer game-feel staples: variable-height jump cuts, wall-sliding with friction speed damping, wall-jumping with collision grace timers, and a zero-gravity air dash coroutine.

I also implemented a status modifier system that handles speed multipliers (e.g. slowing in toxic gas), temporary control inversion, and powerup dash unlocking.

The scientist jumping over a dog poop hazard on a massive wooden shelf platform
Example of the jump mechanic in use
  • Variable Jump Cut: Releases upward momentum early when releasing the jump button (jumpCutMultiplier = 0.5f).
  • Wall-Slide & Wall-Jump: Applies friction on wall contact and launches diagonal wall-jump impulses.
  • Air Dash Coroutine: Freezes gravity temporarily and propels the player forward with invulnerability grace.
  • Status Modifiers: Dynamically scales run speed, jump height, and controls when traversing hazards.
06

Reactive Physics Hazards & Traps

I programmed and tuned interactive environmental hazard behaviors (GasCloud.cs, DogPoop.cs, FallingPotion.cs, RollingSystem.cs).

Hazards react to player and world physics: rolling chemical cylinders roll down slopes with locked rotation physics; proximity-triggered overhead flasks drop and shatter into lingering chemical gas clouds that reduce player movement speed by 50%; and organic slip traps create sudden loss-of-traction hazards.

Laboratory hazards including falling chemical potions and rolling test tubes
Reactive physics hazards: dropping chemical flasks, gas clouds, and rolling test tubes
07

2D Pixel Art & Environment Design

In addition to gameplay programming, I authored pixel art visual assets for Shrunk Paws.

I created the scientist protagonist character sprites and running/jumping animation cycles, modular laboratory tilesets configured with Unity's autotiling rules, obstacle hazard sprites (falling chemical potions, toxic gas clouds, rolling test tubes), and multi-layered parallax background vistas.

Pixel-art scientist sprites, laboratory tilesets, and environmental props
Handcrafted pixel-art sprites, laboratory tilesets, and hazard animations

Like what you see?

Try it yourself, or get in touch to talk about how it was built.