Pre-Production gave me a complete blueprint. Production is where it becomes a game. Three sprints in, Fizzics went from an empty Unity scene to a playable prototype with merge mechanics, chain reactions, explosion VFX, haptic feedback, and a scoring system, all backed by 205 passing tests.
Here's what each sprint delivered, what surprised me, and what "always shippable" actually looks like when you're wrangling physics-based blobs at 60fps.
Sprint 1: Foundation
Goal: Get blobs in a beaker with physics and rendering.
The first sprint was entirely infrastructure. The kind of work that produces screenshots no one would share on social media:
- Beaker container with collision boundaries
- Blob physics via Rigidbody2D + CircleCollider2D
- Metaball rendering pipeline (the validated spike, promoted to production code)
- Input handling. Slide to position, release to drop
- Preview UI. Next-blob indicator
The metaball shader from the spike transferred cleanly. Half-resolution rendering at 0.5x, per-color distance fields, URP Bloom for glow. The spike-first approach paid for itself immediately. No surprises, no rework, no "well actually this doesn't work at scale."
Even Sprint 1 was end-to-end. I could drop blobs, see them rendered with glow, and watch them pile up in the beaker. Not a merge in sight, but it felt like a game already. There's something weirdly satisfying about watching physics objects pile up, even when "pile up" is the entire feature set.
Sprint 2: Core Gameplay
Goal: Make it actually playable.
This is where the game emerged:
- Same-color merge. When same-colored, same-sized blobs touch, they combine into the next size tier with a metaball animation.
- Critical mass detonation. Volatile (max tier) blobs explode in procedural particle bursts.
- Chain reactions. Detonation splash displaces nearby blobs into new merges, triggering cascading reactions.
- Catalyst mechanic. An emergency "save" button that promotes all blobs by one tier (earned through gameplay, max 1 per run).
- Scoring system. Merge points (10/20/30 per tier) + detonation points (100 x 2^chainIndex).
- HUD. Live score display, next-blob preview, catalyst charge indicator.
The chain reaction system was the most complex piece, and the most fun to build. When a blob detonates, the explosion applies force to nearby blobs. Some get pushed into same-colored neighbors, triggering merges. Those merges can create new Volatile blobs, which detonate, which push more blobs... The scoring multiplier doubles with each chain link: 1x → 2x → 4x → 8x.
Getting the cascade detection right took several iterations. I settled on a coroutine-based approach: after each detonation, wait a short physics settle window, then check for new merges. If found, continue the chain. If not, end the cascade and award the final score. The settle window was the tricky part. Too short and you miss merges, too long and the game feels sluggish. I ended up at 0.3 seconds, which feels instantaneous but gives physics time to resolve.
The mid-sprint pivot. The original design had blobs merging by volume (3 small blobs equal 1 big blob). Playtesting revealed this was confusing. I couldn't predict when a merge would happen, and I designed the game. If the developer can't intuit the rules, players have no chance. Switching to Suika's pair-merge model (same color + same size = next tier up) made the game immediately more readable. Sometimes the right design is the one you steal from someone who already figured it out.
Sprint 3: Game Feel
Goal: Make it feel good.
The mechanics worked. Now I needed the layer that turns "it works" into "I can't stop playing":
- Difficulty scaling. Start with 3 colors, add up to 6 as score increases. Drop speed ramps up gradually enough that you don't notice until you're already in trouble.
- Explosion VFX. Procedural particle bursts with color-matched neon glow.
- Haptic feedback via Core Haptics:
- Blob lands: light impact (0.3 intensity)
- Same-color merge: satisfying tick (0.4 intensity)
- Detonation: heavy impact (0.8 intensity)
- Chain reactions: escalating impacts (0.3 → 0.8) per link
- Sound effects. Synth tones for merges, bass hits for detonations, pitch-escalating chain audio.
- Game over flow. Overflow detection, score reveal with count-up animation, instant restart.
The haptic work was surprisingly impactful. A heavy thud on detonation plus escalating vibrations during chain reactions made the game feel physical in a way that audio alone couldn't match. Most casual puzzle games don't use Core Haptics at all, which means it's free differentiation. The hardware is right there in everyone's pocket, just waiting for someone to actually use it.
205 Tests
Every sprint maintained the test suite. By the end of Sprint 3: 205 Edit Mode tests passing.
The ScriptableObject Events architecture made testing straightforward. Systems are decoupled, so I can test the merge system without the rendering system, the scoring system without the UI, the chain detection without actual physics. No mocking frameworks needed. Just create the SO event, register a test listener, and verify it fires.
[Test]
public void MergeSameColorSameSize_ProducesNextTier()
{
var blob1 = CreateBlob(BlobColor.Cyan, BlobTier.Droplet);
var blob2 = CreateBlob(BlobColor.Cyan, BlobTier.Droplet);
mergeSystem.TryMerge(blob1, blob2);
Assert.AreEqual(BlobTier.Globule, blob1.Tier);
Assert.IsFalse(blob2.IsActive);
}
[Test]
public void VolatileBlob_Detonates_TriggersChainEvent()
{
var blob = CreateBlob(BlobColor.Magenta, BlobTier.Volatile);
reactionSystem.CheckCriticalMass(blob);
Assert.IsTrue(onDetonationEvent.WasRaised);
Assert.IsTrue(onChainStartEvent.WasRaised);
}What's Next
Sprint 4 focuses on persistence, ads integration, and final polish. The core game loop is complete and playable. From here, it's about getting it ready for real players: saving high scores, integrating Game Center leaderboards, and the inevitable playtesting feedback loop where people do things with my game that I never anticipated and probably didn't want.
Three sprints in, Fizzics is a game I can pick up, play, and want to play again. That's the milestone that matters. Not feature completeness, not code coverage, not architecture diagrams. Does it feel good to play? Yes. Ship the rest later.