Wood Rush Jam

{Wood Rush Jam} Project Report

1. The Concept

Wood Rush Jam is a slide-to-exit block puzzle for phones. Colored candy polyominoes sit on a 6×6 wooden grid. Each color has a matching door on the frame. The player’s job is simple to explain and hard to master:

Slide a block until it kisses its own color door — then it rushes out.

It is a Unblock-Me / Color Block Jam loop, but the identity is a sunlit toy workshop: glossy per-cell candies with embossed icons, a cream HUD, teal 3D buttons, and Khmer + English copy. The unique hook is the rush itself — hit-stop, a star burst, the door flash, the piece shrinking off the board — so clearing a color feels like a toy snapping into a slot, not a grid cell disappearing.

Design goals:

• Instant rules (Level 1 hand: “DRAG THIS BLOCK”; skip if you already know)
• Soft ramp across 100 levels (hand templates, color-shift, mirror, axis lock from level 9)
• Beginner tools (unlimited undo, 3 hammers, 3 hints per level) that help without erasing pride
• One clear win loop: slide → rush out → celebrate stars → next level
• A smartphone game UI (one job per screen), not a web dashboard

Risk/reward sits in the board, not a shop. Early pieces move on both axes; later bars lock to one axis, so a greedy slide can trap a color behind another. Stars grade cleanliness against par. Same-color pieces start apart on purpose — the puzzle is bringing them to their door, not finding a cluster that is already solved.

2. The Stack

Built as a zero-build, zero-dependency product so it can ship and play the same day.

Layer Choice ----------- ---------------------------------------------------------------- Structure index.html (home, play HUD, board, boosters, pause / levels / win) UI Vanilla CSS (toy-workshop tokens, safe-area, svh / visualViewport) Logic Vanilla JavaScript ("use strict", ~1,400 lines) Art CSS candy cells + SVG icons per color; star burst in an fx layer Audio Web Audio API (procedural SFX + three-note win fanfare; no files) Progress localStorage (woodJamSave) — level, unlocks, stars, best, lang, sound, tutorial flag, hammers / hints Target Phone browser (portrait, viewport-fit=cover, user-scalable=no) Fonts Fredoka + Kantumruy Pro (Google Fonts)

No framework, no bundler, no npm — open the folder and play.

Architecture choices: hand-authored templates sit apart from makeLevel (color rotate, mirror, axis lock, gate packing); UI strings live in D.en / D.km; tunables live in PARAMS (hit-stop, exit ms, tool counts, SFX gain). Design constraints live in sakurai/ and rules/ plus sakurai_game_contnt_v1.0_kh.txt, not in a separate engine.

3. The 1 Day Sprint (+ polish pass)

The day was treated as a full vertical slice: concept → playable core → juice → shippable demo. Scope stayed tight: one mechanic, one wooden toy world, one 100-level path. Anything that did not serve “slide the candy into its door, and feel the rush” was cut.

Morning (Hours 1–3):

• Locked the fantasy from a screenshot + reference video: glossy polyominoes (bars, L, 2×2), icon on every cell, doors on the wooden frame.
• Built the play shell: HUD (restart / level / pause), 6×6 board, UNDO / HAMMER / HINT.
• Implemented occupancy, axis travel, pointer drag with snap-to-cell, and color-matched exits.
• Hit a real blocker: candy wrappers used pointer-events: none + CSS filter, so taps never moved a piece; then a typo in level 1 data emptied the board entirely. Both had to be fixed before the loop existed.
• Tucked oversized gates onto the frame so they stopped covering the Hammer button.

Outcome: A clickable (then draggable) prototype that already looked like the toy, not a wireframe.

Afternoon (Hours 4–6):

• Followed the reference video for the rush: settle, auto-drain when a piece already kisses its door, hit-stop, star particles flying to the HUD counter.
• Wired 100 levels from a small template set (shift / mirror / packGates) plus par for 1–3 stars.
• Built the home screen (PLAY, level chip, progress, stars / 300), pause, paged level select, Khmer / English toggle, localStorage.
• Capped tools at 3 hammers and 3 hints per level; undo stays unlimited so a bad slide is never a dead end.
• First Web Audio pass (move, blocked, impact, assist, win); vibration on block and exit.

Outcome: A real campaign with a home, not a single hand-made puzzle.

The Finish Line (Hour 7-8):

• Renamed the product Wood Rush Jam (logo, title, home).
• Tightened exit rules from playtest: a piece only rushes when it is adjacent to its door; a gap in between does not count; no click-to-clear — slide only.
• Same-color pieces spawn apart so the player must make the meeting, not start with it.
• Win panel: gold star SVGs, LEVEL CLEAR, moves vs best, NEW BEST, next / replay.
• Sakurai pass: skip on the tutorial, pause, large teal tools, toast feedback, debug overlay (?debug=1).

Outcome: A self-contained demo ready to show, share, or iterate.

Polish (Aug 10):

The studio juice pass for this title landed the same day as the sprint (Aug 19), after the core loop shipped:

• Candy cells: per-cell bevel, inset tray, embossed SVG (diamond / bolt / star / circle).
• Sunlit toy-workshop skin: cream level badge, teal 3D buttons, oak plank background, cream win panel.
• Star fly-in on every exit, HUD count pop, gate flash, piece shrink-out.
• Home logo (WOOD RUSH + toy JAM blocks), Fredoka / Kantumruy type.
• Mobile viewport lock (visualViewport → --app-height, fitBoard) so Safari’s URL bar and the notch stop eating the HUD, gates, and boosters.
• Copy: “Level” not “Lv.”; labels stay readable in Khmer.

4. The Roadblocks

1. Input that looked like a game but was not playable — Candy cells inside a pointer-events: none wrapper plus a CSS filter swallowed taps. A stray } in level 1 then killed the whole script, so the board rendered empty. The loop only existed after pointer capture sat on the block itself and the data parsed.

1. Exits that lied — Early gates were full-size blocks sitting off the grid (one covered Hammer). Then auto-clear fired on a tap, or on a piece that was merely “facing” its door with a gap. Playtest forced the real rule: slide only; rush only when the piece is flush with the matching door.

1. Feel vs. cheap motion — Click-to-slide and double-tap-to-exit made the board feel twitchy. The video process was drag → settle → drain. Hit-stop + star burst + shrink-out replaced “pop gone.”

1. Same-color clustering — Generator / templates parked matching colors next to each other, so the first glance already looked solved. Spreading them apart restored the “bring them together” puzzle.

1. Phone chrome — 100dvh and 85vw left dead space, clipped side gates, and parked UNDO / HAMMER / HINT on Safari’s URL bar. Board size had to come from the visible play zone, not a magic viewport formula.

1. Audio without assets — No sound pack in a 1-day sprint. Web Audio oscillators carry move / block / impact / assist / win; browsers still need a user gesture to unlock the context.

1. Scope pressure — Shop, ads, accounts, and a full solver were tempting. Seeded templates + undo / hammer / hint kept the day on one composition: brand, one loop, 100 levels, ship.

5. Key Takeaways

• One sentence concept + three static files is enough to ship a complete 100-level slide-to-exit loop in a day.
• Familiar rules (Unblock Me) + a local identity (toy candy, rush-out, Khmer) beats inventing a new mechanic under time pressure.
• Feel is product: hit-stop, star fly, and “slide not tap” mattered as much as exitFor for “this is a game.”
• If the player cannot drag on minute one, the art does not matter. Input and a parsing typo burned the morning; that was the real vertical slice.
• Cut features early; polish the core loop (slide → kiss the door → rush) instead of spreading thin across meta systems.
• Design docs (sakurai/, rules/, sakurai_game_contnt_v1.0_kh.txt) kept screens honest: one job, portrait, skippable tutorial, assist that does not shame.

My final thought:

A one-day game only works when the concept is a single sentence and the stack stays out of the way. Wood Rush Jam proves that: drag the candy, kiss the door, watch it rush; Khmer on the pause menu; a full campaign with tools, stars, and a home screen inside three files. The next steps are optional — handcrafted late levels, richer audio, a real solvability check — but the core already delivers what mattered most: slide it in, see the stars fly, smile, next.