Tower Stack Timing Game — Click-to-Drop Block Stacker with Real Overlap Physics

This is a complete implementation of the classic "stack the moving block" timing game: a block slides back and forth, the player taps to drop it, and it locks into place based on how much it actually overlaps the block beneath it — narrowing the tower with every imperfect placement, exactly like the real mechanic this genre is built on.

Overlap is computed geometrically, not guessed

placeBlock() computes the actual intersecting region between the moving block's current position and the block directly below it: left = Math.max(currentX, prev.x), right = Math.min(currentX + currentWidth, prev.x + prev.width), and overlap = right - left. This is real interval-intersection math — the same logic used to detect whether two 1D ranges overlap and by how much — not a simplified "close enough" heuristic. If overlap comes out at or below a small tolerance (4px, accounting for the player landing an essentially perfect but not pixel-exact hit), the game ends immediately.

Every successful placement narrows what's possible next

The block that gets placed isn't the full-width moving block — it's a new block sized to exactly the overlap region, and currentWidth for the *next* moving block is set to that same shrunken width. This is what creates the genre's core difficulty curve: a series of imperfect-but-passable placements compounds, making each subsequent block progressively harder to land, purely as an emergent consequence of the overlap math rather than a separately scripted difficulty ramp.

Speed scales with height, within a capped range

speed = Math.min(6, 2.2 + stack.length * 0.15) increases the moving block's horizontal speed as the tower gets taller, but caps out at 6 — so the game gets meaningfully harder as a player progresses without becoming literally unplayable at very tall heights, a deliberate balance between "there is a real difficulty curve" and "the game doesn't become impossible."

The camera scroll only activates once it's actually needed

render() checks whether the tower's total pixel height exceeds the visible viewport area, and only applies a translateY "camera scroll" transform once it does — short towers render with no scroll offset at all, and the scroll amount is computed exactly from how far the tower has grown past the visible boundary, so the currently-moving block and the top of the tower remain visible together throughout play, not just for the first several blocks.

Persistent best height, not just a session high score

Same as this library's other playable games, the best height achieved is read from and written to localStorage (towerStackBest), so a player's personal best is meaningful across page reloads rather than resetting every time the page loads.