feat(generation): event-based patterns, boost-aware pacing, colored cubes

Patterns are now deliberate events — slalom clusters, gates, spirals,
rails, weave pinches — separated by blank beats instead of per-cell
density dice, so each obstacle reads as an intentional moment. Event
gaps stretch with the boost multiplier at generation time, giving the
player constant reaction time at any speed, and the telegraph horizon
scales with speed too. Every event gets a palette color shared by its
cubes, the telegraph trail leading to them, and the debug overlay.
Also fixes the longitudinal grid lines (a stale scratch-vector reference
collapsed them into duplicate ring segments).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: crs48

.claude/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "vite-dev",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["run", "dev"],
+      "port": 5173
+    },
+    {
+      "name": "vite-preview",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": ["run", "preview"],
+      "port": 4173
+    }
+  ]
+}

src/game/run.ts

@@ -3,6 +3,7 @@
 // hands the result to the render layer.
 
 import { resolveCollisionFrame } from "./collision";
+import { BOOST_MULTIPLIERS } from "./config";
 import { maybeUpdateHighScore, scoreFromDistance } from "./scoring";
 import { advancePlayer, createInitialGameState, type GameState } from "./state";
 import {
@@ -45,7 +46,11 @@ export const updateRun = (
 ): RunState => {
   const advancedPlayer = advancePlayer(state.game.player, { steer }, dtSeconds);
   const world = trimWorldBehind(
-    ensureWorldAhead(state.world, advancedPlayer.distance),
+    ensureWorldAhead(
+      state.world,
+      advancedPlayer.distance,
+      BOOST_MULTIPLIERS[advancedPlayer.boostLevel],
+    ),
     advancedPlayer.distance,
   );
   const collisionState = framesNearDistance(world, advancedPlayer.distance).reduce<CollisionPass>(

src/game/world.ts

@@ -22,6 +22,7 @@ export type WorldFrame = {
   readonly section: Section;
   readonly sectionCell: CellIndex;
   readonly obstacleMask: LaneMask;
+  readonly colorIndex: number;
   readonly boost?: BoostCell;
 };
 
@@ -33,7 +34,7 @@ export const createWorld = (seed: number, startLane: Lane): World => ({
   sections: [generateSection({ id: 0, seed, startLane })],
 });
 
-const appendSection = (world: World): World => {
+const appendSection = (world: World, speedFactor: number): World => {
   const last = world.sections.at(-1);
 
   if (last === undefined) {
@@ -47,6 +48,7 @@ const appendSection = (world: World): World => {
     seed: world.seed,
     startLane,
     startDistance: last.endDistance,
+    speedFactor,
   });
 
   return {
@@ -55,15 +57,19 @@ const appendSection = (world: World): World => {
   };
 };
 
-export const ensureWorldAhead = (world: World, distance: number): World => {
+export const ensureWorldAhead = (
+  world: World,
+  distance: number,
+  speedFactor = 1,
+): World => {
   const requiredDistance = distance + VISIBLE_CELLS * 4;
   const last = world.sections.at(-1);
 
   if (last !== undefined && last.endDistance >= requiredDistance) {
     return world;
   }
 
-  return ensureWorldAhead(appendSection(world), distance);
+  return ensureWorldAhead(appendSection(world, speedFactor), distance, speedFactor);
 };
 
 export const trimWorldBehind = (world: World, distance: number): World => ({
@@ -101,6 +107,7 @@ export const frameAtDistance = (
     section,
     sectionCell,
     obstacleMask,
+    colorIndex: section.cellColors[sectionCell] ?? 0,
     ...(boost === undefined ? {} : { boost }),
   };
 };

src/generation/patterns.ts

@@ -1,8 +1,10 @@
-import { LANES } from "../tube/space";
+// Pattern events: instead of rolling density dice per cell, sections place
+// deliberate "events" — a gate, a slalom cluster, a rail — separated by
+// blank cells. The player always reads one intentional thing at a time, and
+// the section can stretch the gaps when it is generated at boost speed.
+
 import {
-  clearLane,
   corridorMask,
-  hasLane,
   invertLaneMask,
   laneMask,
   normalizeLane,
@@ -12,100 +14,118 @@ import {
 import type { Rng } from "./rng";
 
 export const PATTERN_FAMILIES = [
-  "semiRandom",
-  "staggered",
+  "slalom",
+  "gates",
   "spiral",
-  "line",
-  "wall",
+  "rail",
+  "weave",
 ] as const;
 
 export type PatternFamily = (typeof PATTERN_FAMILIES)[number];
 
-export type PatternInput = {
+export type PatternEvent = {
+  // One mask per cell of the event's span, relative to the event's start.
+  readonly masks: readonly LaneMask[];
+  // Blank cells after the event at base speed; scaled up while boosted.
+  readonly gapAfter: number;
+};
+
+export type EventInput = {
   readonly rng: Rng;
   readonly family: PatternFamily;
-  readonly cellIndex: number;
-  readonly safeLane: Lane;
+  readonly eventIndex: number;
+  // Safe path from the event's first cell onward.
+  readonly safeLanes: readonly Lane[];
   readonly safeWidth: number;
-  readonly density: number;
-  readonly sectionId: number;
+  // 0 (warmup) … 1 (late game).
+  readonly difficulty: number;
 };
 
-const addRandomBlockers = (
-  rng: Rng,
-  availableMask: LaneMask,
-  density: number,
-): LaneMask =>
-  Array.from({ length: LANES }, (_, lane) => lane)
-    .filter((lane) => hasLane(availableMask, lane))
-    .reduce<LaneMask>(
-      (mask, lane) => (rng.next() < density ? mask | laneMask(lane) : mask),
-      0,
-    );
-
-const createSemiRandomMask = (input: PatternInput, availableMask: LaneMask): LaneMask =>
-  addRandomBlockers(input.rng, availableMask, input.density);
-
-const createStaggeredMask = (input: PatternInput, availableMask: LaneMask): LaneMask => {
-  const side = Math.floor(input.cellIndex / 2) % 2 === 0 ? -1 : 1;
-  const offsets = [side * 2, side * 3, -side * 5];
-
-  return offsets.reduce<LaneMask>((mask, offset) => {
-    const lane = normalizeLane(input.safeLane + offset);
-    return hasLane(availableMask, lane) ? mask | laneMask(lane) : mask;
-  }, 0);
-};
+const lanesToMask = (lanes: readonly number[]): LaneMask =>
+  lanes.reduce<LaneMask>((mask, lane) => mask | laneMask(normalizeLane(lane)), 0);
+
+const safeLaneAt = (input: EventInput, offset: number): Lane =>
+  input.safeLanes[Math.min(offset, input.safeLanes.length - 1)] ?? 0;
 
-const createSpiralMask = (input: PatternInput, availableMask: LaneMask): LaneMask => {
-  const direction = input.sectionId % 2 === 0 ? 1 : -1;
-  const baseLane = normalizeLane(input.sectionId * 3);
-  const leadLane = normalizeLane(baseLane + input.cellIndex * direction);
-  const mask = [leadLane, leadLane + direction, leadLane + direction * 3]
-    .reduce<LaneMask>((acc, lane) => acc | laneMask(lane), 0);
+// One small cluster right beside the corridor, alternating sides: cubes
+// flick past the player's shoulder and punish drifting.
+const slalomEvent = (input: EventInput): PatternEvent => {
+  const side = input.eventIndex % 2 === 0 ? 1 : -1;
+  const edge = input.safeWidth + 1;
+  const safe = safeLaneAt(input, 0);
+  const offsets = input.difficulty > 0.4 ? [edge, edge + 1] : [edge];
 
-  return mask & availableMask;
+  return {
+    masks: [lanesToMask(offsets.map((offset) => safe + side * offset))],
+    gapAfter: input.difficulty > 0.7 ? 2 : 3,
+  };
 };
 
-const createLineMask = (input: PatternInput, availableMask: LaneMask): LaneMask => {
-  const firstLine = normalizeLane(input.sectionId + Math.floor(input.cellIndex / 10));
-  const secondLine = normalizeLane(firstLine + 6);
+// A full ring with a gap centered on the safe path: see the wall, find the
+// hole, steer to it.
+const gatesEvent = (input: EventInput): PatternEvent => {
+  const gapHalf = input.difficulty > 0.5 ? 1 : 2;
+  const safe = safeLaneAt(input, 0);
 
-  return [firstLine, secondLine].reduce<LaneMask>(
-    (mask, lane) => (hasLane(availableMask, lane) ? mask | laneMask(lane) : mask),
-    0,
-  );
+  return {
+    masks: [invertLaneMask(corridorMask(safe, Math.max(gapHalf, input.safeWidth)))],
+    gapAfter: 5 - Math.round(input.difficulty * 2),
+  };
 };
 
-const createWallMask = (input: PatternInput, safeMask: LaneMask): LaneMask => {
-  if (input.cellIndex % 9 !== 0) {
-    return createSemiRandomMask(input, invertLaneMask(safeMask)) & 0b001_001_001_001;
-  }
+// A short two-lane-thick helix sweeping around the ring beside the corridor,
+// alternating sweep direction between events.
+const spiralEvent = (input: EventInput): PatternEvent => {
+  const direction = input.eventIndex % 2 === 0 ? 1 : -1;
+  const span = 5;
+  const masks = Array.from({ length: span }, (_, step) => {
+    const base = safeLaneAt(input, step) + direction * (input.safeWidth + 1 + step);
+    return lanesToMask([base, base + direction]);
+  });
+
+  return { masks, gapAfter: 4 };
+};
 
-  const widerSafeMask = corridorMask(input.safeLane, Math.max(input.safeWidth, 1));
-  const wallMask = invertLaneMask(widerSafeMask);
-  const reliefLane = normalizeLane(input.safeLane + (input.sectionId % 2 === 0 ? 4 : -4));
+// A solid two-lane ribbon riding one side of the corridor for several cells:
+// a wall that travels with you and frames the path.
+const railEvent = (input: EventInput): PatternEvent => {
+  const side = input.eventIndex % 2 === 0 ? -1 : 1;
+  const span = 8 + input.rng.nextInt(0, 4);
+  const masks = Array.from({ length: span }, (_, step) => {
+    const safe = safeLaneAt(input, step);
+    return lanesToMask([
+      safe + side * (input.safeWidth + 1),
+      safe + side * (input.safeWidth + 2),
+    ]);
+  });
+
+  return { masks, gapAfter: 4 };
+};
 
-  return clearLane(wallMask, reliefLane);
+// A pinch: cubes flanking both sides of the corridor at once — hold the line.
+const weaveEvent = (input: EventInput): PatternEvent => {
+  const edge = input.safeWidth + 1;
+  const safe = safeLaneAt(input, 0);
+  const offsets =
+    input.difficulty > 0.5 ? [edge, edge + 1, -edge, -edge - 1] : [edge, -edge];
+
+  return {
+    masks: [lanesToMask(offsets.map((offset) => safe + offset))],
+    gapAfter: 3,
+  };
 };
 
-export const createPatternMask = (input: PatternInput): LaneMask => {
-  const safeMask = corridorMask(input.safeLane, input.safeWidth);
-  const availableMask = invertLaneMask(safeMask);
-
-  const rawMask = (() => {
-    switch (input.family) {
-      case "semiRandom":
-        return createSemiRandomMask(input, availableMask);
-      case "staggered":
-        return createStaggeredMask(input, availableMask);
-      case "spiral":
-        return createSpiralMask(input, availableMask);
-      case "line":
-        return createLineMask(input, availableMask);
-      case "wall":
-        return createWallMask(input, safeMask);
-    }
-  })();
-
-  return rawMask & availableMask;
+export const createPatternEvent = (input: EventInput): PatternEvent => {
+  switch (input.family) {
+    case "slalom":
+      return slalomEvent(input);
+    case "gates":
+      return gatesEvent(input);
+    case "spiral":
+      return spiralEvent(input);
+    case "rail":
+      return railEvent(input);
+    case "weave":
+      return weaveEvent(input);
+  }
 };