groove-dev 0.27.112 → 0.27.113

package/codex-test/offroad-nitro-racer/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "offroad-nitro-racer",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "typescript": "latest",
+    "vite": "latest"
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/AI.ts

@@ -0,0 +1,28 @@
+import { Car, DriverInput } from './Car';
+import { Track } from './Track';
+import { angleTo, clamp, normalizeAngle } from './math';
+
+export class AIController {
+  private aggression: number;
+  private lookahead: number;
+
+  constructor(index: number) {
+    this.aggression = 0.84 + index * 0.06;
+    this.lookahead = 1 + (index % 2);
+  }
+
+  update(car: Car, track: Track, playerRank: number, difficulty: number): DriverInput {
+    const targetIndex = (car.nextCheckpoint + this.lookahead) % track.checkpoints.length;
+    const target = track.nextCheckpoint(targetIndex);
+    const desired = angleTo(car, target);
+    const delta = normalizeAngle(desired - car.angle);
+    const steer = clamp(delta * 2.2, -1, 1);
+    const caution = Math.abs(delta) > 0.8 ? 0.45 : Math.abs(delta) > 0.45 ? 0.7 : 1;
+    const catchup = playerRank < car.rank ? 1.08 : 0.95;
+    const throttle = clamp(this.aggression * caution * catchup + difficulty * 0.04, 0.35, 1);
+    const brake = Math.abs(delta) > 1.15 && car.speed > 115 ? 0.65 : 0;
+    const nitro = car.nitroCharges > 0 && Math.abs(delta) < 0.22 && car.speed > 135 && Math.random() < 0.015 + difficulty * 0.004;
+
+    return { throttle, brake, steer, nitro };
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/Audio.ts

@@ -0,0 +1,63 @@
+import { clamp } from './math';
+
+export class AudioSystem {
+  private ctx: AudioContext | null = null;
+  private master: GainNode | null = null;
+  private engineOsc: OscillatorNode | null = null;
+  private engineGain: GainNode | null = null;
+
+  ensure(): void {
+    if (this.ctx) return;
+
+    const Ctx = window.AudioContext || (window as unknown as { webkitAudioContext: typeof AudioContext }).webkitAudioContext;
+    this.ctx = new Ctx();
+    this.master = this.ctx.createGain();
+    this.master.gain.value = 0.18;
+    this.master.connect(this.ctx.destination);
+
+    this.engineOsc = this.ctx.createOscillator();
+    this.engineGain = this.ctx.createGain();
+    this.engineOsc.type = 'sawtooth';
+    this.engineOsc.frequency.value = 70;
+    this.engineGain.gain.value = 0;
+    this.engineOsc.connect(this.engineGain);
+    this.engineGain.connect(this.master);
+    this.engineOsc.start();
+  }
+
+  updateEngine(speed: number, throttle: number, boosting: boolean): void {
+    if (!this.ctx || !this.engineOsc || !this.engineGain) return;
+    const now = this.ctx.currentTime;
+    this.engineOsc.frequency.setTargetAtTime(65 + clamp(speed, 0, 240) * 1.2 + (boosting ? 70 : 0), now, 0.04);
+    this.engineGain.gain.setTargetAtTime(0.025 + Math.abs(throttle) * 0.05 + (boosting ? 0.035 : 0), now, 0.05);
+  }
+
+  beep(kind: 'count' | 'go' | 'pickup' | 'boost' | 'hit' | 'finish'): void {
+    this.ensure();
+    if (!this.ctx || !this.master) return;
+
+    const now = this.ctx.currentTime;
+    const osc = this.ctx.createOscillator();
+    const gain = this.ctx.createGain();
+    const settings = {
+      count: [440, 0.12, 'square'],
+      go: [780, 0.35, 'triangle'],
+      pickup: [920, 0.18, 'sine'],
+      boost: [120, 0.42, 'sawtooth'],
+      hit: [80, 0.18, 'square'],
+      finish: [660, 0.7, 'triangle'],
+    } as const;
+    const [frequency, duration, type] = settings[kind];
+
+    osc.type = type;
+    osc.frequency.setValueAtTime(frequency, now);
+    if (kind === 'boost') osc.frequency.exponentialRampToValueAtTime(240, now + duration);
+    if (kind === 'hit') osc.frequency.exponentialRampToValueAtTime(45, now + duration);
+    gain.gain.setValueAtTime(kind === 'hit' ? 0.13 : 0.18, now);
+    gain.gain.exponentialRampToValueAtTime(0.001, now + duration);
+    osc.connect(gain);
+    gain.connect(this.master);
+    osc.start(now);
+    osc.stop(now + duration + 0.02);
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/Car.ts

@@ -0,0 +1,247 @@
+import { Effects } from './Effects';
+import { Track } from './Track';
+import { Vec2, clamp, dot, length, normalizeAngle } from './math';
+
+export type DriverInput = {
+  throttle: number;
+  brake: number;
+  steer: number;
+  nitro: boolean;
+};
+
+export type CarConfig = {
+  name: string;
+  color: string;
+  accent: string;
+  isPlayer?: boolean;
+};
+
+export class Car {
+  name: string;
+  color: string;
+  accent: string;
+  isPlayer: boolean;
+  x: number;
+  y: number;
+  vx = 0;
+  vy = 0;
+  angle: number;
+  radius = 24;
+  width = 34;
+  length = 54;
+  nitroCharges = 2;
+  maxNitro = 3;
+  nitroTimer = 0;
+  nextCheckpoint = 0;
+  lap = 1;
+  finished = false;
+  finishTime = 0;
+  airborne = 0;
+  verticalVelocity = 0;
+  driftAmount = 0;
+  collectedPickup = false;
+  lastProgress = 0;
+  totalProgress = 0;
+  rank = 1;
+  wrongWayTimer = 0;
+
+  constructor(config: CarConfig, start: Vec2 & { angle: number }) {
+    this.name = config.name;
+    this.color = config.color;
+    this.accent = config.accent;
+    this.isPlayer = Boolean(config.isPlayer);
+    this.x = start.x;
+    this.y = start.y;
+    this.angle = start.angle;
+  }
+
+  get speed(): number {
+    return Math.hypot(this.vx, this.vy);
+  }
+
+  reset(start: Vec2 & { angle: number }): void {
+    this.x = start.x;
+    this.y = start.y;
+    this.vx = 0;
+    this.vy = 0;
+    this.angle = start.angle;
+    this.nitroCharges = this.isPlayer ? 2 : 1;
+    this.nitroTimer = 0;
+    this.nextCheckpoint = 0;
+    this.lap = 1;
+    this.finished = false;
+    this.finishTime = 0;
+    this.airborne = 0;
+    this.verticalVelocity = 0;
+    this.totalProgress = 0;
+    this.lastProgress = 0;
+    this.rank = 1;
+  }
+
+  update(delta: number, input: DriverInput, track: Track, effects: Effects, raceTime: number, difficulty = 1): void {
+    if (this.finished) {
+      this.vx *= 1 - delta * 2;
+      this.vy *= 1 - delta * 2;
+      return;
+    }
+
+    this.collectedPickup = false;
+
+    const terrain = track.sample(this.x, this.y);
+    const forwardX = Math.cos(this.angle);
+    const forwardY = Math.sin(this.angle);
+    const rightX = -forwardY;
+    const rightY = forwardX;
+    const forwardSpeed = dot(this.vx, this.vy, forwardX, forwardY);
+    const sideSpeed = dot(this.vx, this.vy, rightX, rightY);
+    const movingFactor = clamp(Math.abs(forwardSpeed) / 90, 0.25, 1);
+    const steerPower = (2.15 + difficulty * 0.08) * terrain.grip * movingFactor;
+
+    this.angle = normalizeAngle(this.angle + input.steer * steerPower * delta * (forwardSpeed >= -15 ? 1 : -1));
+
+    let acceleration = input.throttle * (230 + difficulty * 12) - input.brake * 320;
+    const boosting = input.nitro && this.nitroCharges > 0 && this.nitroTimer <= 0 && input.throttle > 0;
+    if (boosting) {
+      this.nitroCharges -= 1;
+      this.nitroTimer = 1.15;
+      effects.add('boost', this.x, this.y, this.angle, 12);
+      effects.impact(this.isPlayer ? 5 : 2);
+    }
+
+    if (this.nitroTimer > 0) {
+      this.nitroTimer -= delta;
+      acceleration += 360;
+      if (Math.random() < 0.8) effects.add('boost', this.x - forwardX * 26, this.y - forwardY * 26, this.angle, 1);
+    }
+
+    const maxSpeed = (this.nitroTimer > 0 ? 330 : 235 + difficulty * 8) * terrain.speedMultiplier;
+    this.vx += forwardX * acceleration * delta;
+    this.vy += forwardY * acceleration * delta;
+
+    const newForwardSpeed = dot(this.vx, this.vy, forwardX, forwardY);
+    const limitedForward = clamp(newForwardSpeed, -95, maxSpeed);
+    const lateralGrip = this.airborne > 0 ? 0.02 : clamp(terrain.grip * (input.brake > 0 ? 0.72 : 1), 0.08, 1);
+    const limitedSide = sideSpeed * (1 - clamp(delta * (6.5 * lateralGrip), 0, 0.92));
+
+    this.vx = forwardX * limitedForward + rightX * limitedSide;
+    this.vy = forwardY * limitedForward + rightY * limitedSide;
+
+    const drag = 1 - delta * (terrain.terrain === 'rough' ? 1.4 : 0.65);
+    this.vx *= drag;
+    this.vy *= drag;
+
+    this.x += this.vx * delta;
+    this.y += this.vy * delta;
+
+    this.driftAmount = Math.abs(limitedSide) / 90;
+    if (this.speed > 45 && terrain.terrain !== 'track' && Math.random() < 0.7) effects.add('dust', this.x - forwardX * 24, this.y - forwardY * 24, this.angle, 1);
+    if (this.driftAmount > 0.42 && this.airborne <= 0 && Math.random() < 0.6) effects.add('skid', this.x - forwardX * 18, this.y - forwardY * 18, this.angle, 1);
+
+    this.updateAir(delta, track, effects);
+    this.updateCheckpoints(track, raceTime);
+  }
+
+  collideWith(other: Car, effects: Effects): void {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    const dist = length(dx, dy);
+    const minDist = this.radius + other.radius;
+    if (dist <= 0 || dist >= minDist) return;
+
+    const nx = dx / dist;
+    const ny = dy / dist;
+    const overlap = minDist - dist;
+    this.x += nx * overlap * 0.5;
+    this.y += ny * overlap * 0.5;
+    other.x -= nx * overlap * 0.5;
+    other.y -= ny * overlap * 0.5;
+
+    const impulse = dot(this.vx - other.vx, this.vy - other.vy, nx, ny) * 0.55;
+    this.vx -= nx * impulse;
+    this.vy -= ny * impulse;
+    other.vx += nx * impulse;
+    other.vy += ny * impulse;
+    effects.add('spark', (this.x + other.x) / 2, (this.y + other.y) / 2, this.angle, 5);
+    effects.impact(this.isPlayer || other.isPlayer ? 6 : 2);
+  }
+
+  collideObstacles(track: Track, effects: Effects): 'hit' | 'bump' | null {
+    for (const obstacle of track.obstacles) {
+      const dx = this.x - obstacle.x;
+      const dy = this.y - obstacle.y;
+      const dist = length(dx, dy);
+      if (dist >= this.radius + obstacle.radius) continue;
+
+      if (obstacle.kind === 'bump') {
+        if (this.airborne <= 0 && this.speed > 65) {
+          this.verticalVelocity = 180 + this.speed * 0.45;
+          effects.add('dust', this.x, this.y, this.angle, 10);
+          effects.impact(this.isPlayer ? 5 : 1);
+          return 'bump';
+        }
+        continue;
+      }
+
+      const nx = dx / Math.max(dist, 0.01);
+      const ny = dy / Math.max(dist, 0.01);
+      const overlap = this.radius + obstacle.radius - dist;
+      this.x += nx * overlap;
+      this.y += ny * overlap;
+      const impactSpeed = dot(this.vx, this.vy, nx, ny);
+      this.vx -= nx * impactSpeed * 1.55;
+      this.vy -= ny * impactSpeed * 1.55;
+      this.vx *= 0.72;
+      this.vy *= 0.72;
+      effects.add('spark', this.x - nx * this.radius, this.y - ny * this.radius, this.angle, 8);
+      effects.impact(this.isPlayer ? 9 : 2);
+      return 'hit';
+    }
+    return null;
+  }
+
+  private updateAir(delta: number, track: Track, effects: Effects): void {
+    if (this.airborne > 0 || this.verticalVelocity > 0) {
+      this.airborne += this.verticalVelocity * delta;
+      this.verticalVelocity -= 520 * delta;
+      if (this.airborne <= 0) {
+        this.airborne = 0;
+        this.verticalVelocity = 0;
+        if (this.speed > 75) {
+          effects.add('dust', this.x, this.y, this.angle, 14);
+          effects.impact(this.isPlayer ? 7 : 2);
+        }
+      }
+    }
+
+    if (track.consumePickup({ x: this.x, y: this.y })) {
+      this.nitroCharges = Math.min(this.maxNitro, this.nitroCharges + 1);
+      this.collectedPickup = true;
+      effects.add('boost', this.x, this.y, this.angle, 10);
+    }
+  }
+
+  private updateCheckpoints(track: Track, raceTime: number): void {
+    const sample = track.sample(this.x, this.y);
+    const progress = sample.progress;
+    const checkpoint = track.nextCheckpoint(this.nextCheckpoint);
+    const closeEnough = Math.hypot(this.x - checkpoint.x, this.y - checkpoint.y) < 155;
+
+    if (closeEnough) {
+      this.nextCheckpoint += 1;
+      if (this.nextCheckpoint >= track.checkpoints.length) {
+        this.nextCheckpoint = 0;
+        this.lap += 1;
+        if (this.lap > track.lapsToWin) {
+          this.finished = true;
+          this.finishTime = raceTime;
+          this.lap = track.lapsToWin;
+        }
+      }
+    }
+
+    const wrappedProgress = progress < 0.15 && this.lastProgress > 0.85 ? progress + 1 : progress;
+    const lapBase = Math.max(0, this.lap - 1);
+    this.totalProgress = lapBase + wrappedProgress;
+    this.lastProgress = progress;
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/Effects.ts

@@ -0,0 +1,62 @@
+import { Vec2, rand } from './math';
+
+export type ParticleKind = 'dust' | 'skid' | 'spark' | 'boost';
+
+type Particle = Vec2 & {
+  vx: number;
+  vy: number;
+  life: number;
+  maxLife: number;
+  size: number;
+  kind: ParticleKind;
+};
+
+export class Effects {
+  particles: Particle[] = [];
+  shake = 0;
+
+  add(kind: ParticleKind, x: number, y: number, angle = 0, amount = 1): void {
+    for (let i = 0; i < amount; i++) {
+      const speed = kind === 'boost' ? rand(80, 180) : rand(10, 95);
+      const spread = angle + Math.PI + rand(-0.75, 0.75);
+      this.particles.push({
+        x: x + rand(-8, 8),
+        y: y + rand(-8, 8),
+        vx: Math.cos(spread) * speed + rand(-20, 20),
+        vy: Math.sin(spread) * speed + rand(-20, 20),
+        life: kind === 'skid' ? 1.4 : rand(0.25, 0.75),
+        maxLife: kind === 'skid' ? 1.4 : 0.75,
+        size: kind === 'spark' ? rand(2, 5) : rand(6, 18),
+        kind,
+      });
+    }
+  }
+
+  impact(amount: number): void {
+    this.shake = Math.max(this.shake, amount);
+  }
+
+  update(delta: number): void {
+    this.shake = Math.max(0, this.shake - delta * 18);
+    for (const p of this.particles) {
+      p.x += p.vx * delta;
+      p.y += p.vy * delta;
+      p.vx *= 1 - delta * 2.2;
+      p.vy *= 1 - delta * 2.2;
+      p.life -= delta;
+    }
+    this.particles = this.particles.filter((p) => p.life > 0);
+  }
+
+  render(ctx: CanvasRenderingContext2D): void {
+    for (const p of this.particles) {
+      const alpha = Math.max(0, p.life / p.maxLife);
+      ctx.globalAlpha = alpha * (p.kind === 'skid' ? 0.55 : 0.8);
+      ctx.fillStyle = p.kind === 'spark' ? '#ffd166' : p.kind === 'boost' ? '#6ff7ff' : p.kind === 'skid' ? '#282018' : '#c89b66';
+      ctx.beginPath();
+      ctx.ellipse(p.x, p.y, p.size * (1.2 - alpha * 0.3), p.size * 0.45, 0, 0, Math.PI * 2);
+      ctx.fill();
+    }
+    ctx.globalAlpha = 1;
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/Game.ts

@@ -0,0 +1,229 @@
+import { AIController } from './AI';
+import { AudioSystem } from './Audio';
+import { Car, DriverInput } from './Car';
+import { Effects } from './Effects';
+import { Input } from './Input';
+import { Camera, Renderer } from './Renderer';
+import { Track } from './Track';
+import { UI, UiState } from './UI';
+import { clamp, lerp, rand } from './math';
+
+export class Game {
+  private renderer: Renderer;
+  private input = new Input();
+  private audio = new AudioSystem();
+  private ui: UI;
+  private track = new Track();
+  private effects = new Effects();
+  private cars: Car[] = [];
+  private ai: AIController[] = [];
+  private player!: Car;
+  private camera: Camera = { x: 0, y: 0, zoom: 0.72, shakeX: 0, shakeY: 0 };
+  private state: UiState = 'menu';
+  private lastTime = 0;
+  private raceTime = 0;
+  private countdown = 3.4;
+  private message = '';
+  private messageTimer = 0;
+  private winner = '';
+  private countdownBeep = 4;
+  private pausedFrom: UiState = 'racing';
+
+  constructor(canvas: HTMLCanvasElement, overlay: HTMLDivElement) {
+    this.renderer = new Renderer(canvas);
+    this.ui = new UI(overlay);
+    this.resetRace();
+  }
+
+  start(): void {
+    this.ui.render(this.uiData());
+    requestAnimationFrame((time) => this.loop(time));
+  }
+
+  private loop(time: number): void {
+    const delta = Math.min((time - this.lastTime) / 1000 || 0, 0.033);
+    this.lastTime = time;
+
+    this.handleGlobalInput();
+    this.update(delta);
+    this.render();
+    this.input.endFrame();
+
+    requestAnimationFrame((nextTime) => this.loop(nextTime));
+  }
+
+  private handleGlobalInput(): void {
+    if (this.input.consume('enter') && this.state === 'menu') {
+      this.audio.ensure();
+      this.beginCountdown();
+    }
+
+    if (this.input.consume('escape')) {
+      if (this.state === 'racing' || this.state === 'countdown') {
+        this.pausedFrom = this.state;
+        this.state = 'paused';
+      } else if (this.state === 'paused') this.state = this.pausedFrom;
+    }
+
+    if (this.input.consume('r')) {
+      this.resetRace();
+      this.beginCountdown();
+    }
+  }
+
+  private beginCountdown(): void {
+    this.state = 'countdown';
+    this.countdown = 3.4;
+    this.countdownBeep = 4;
+    this.raceTime = 0;
+    this.audio.beep('count');
+  }
+
+  private update(delta: number): void {
+    if (this.state === 'menu' || this.state === 'paused' || this.state === 'finished') {
+      this.updateCamera(delta);
+      return;
+    }
+
+    this.track.update(delta);
+    this.effects.update(delta);
+
+    if (this.state === 'countdown') {
+      this.countdown -= delta;
+      const nextBeep = Math.ceil(this.countdown);
+      if (nextBeep > 0 && nextBeep < this.countdownBeep) {
+        this.countdownBeep = nextBeep;
+        this.audio.beep('count');
+      }
+      if (this.countdown <= 0) {
+        this.state = 'racing';
+        this.audio.beep('go');
+      }
+      this.updateCamera(delta);
+      return;
+    }
+
+    this.raceTime += delta;
+    const difficulty = 1 + (this.player.lap - 1) * 0.12 + this.raceTime / 190;
+    const playerInput = this.readPlayerInput();
+    const wasBoosting = this.player.nitroTimer > 0;
+    this.player.update(delta, playerInput, this.track, this.effects, this.raceTime, difficulty);
+    if (!wasBoosting && this.player.nitroTimer > 0) this.audio.beep('boost');
+
+    for (let i = 1; i < this.cars.length; i++) {
+      const car = this.cars[i];
+      car.update(delta, this.ai[i - 1].update(car, this.track, this.player.rank, difficulty), this.track, this.effects, this.raceTime, difficulty);
+    }
+
+    this.resolveCollisions();
+    this.updateRanks();
+    this.updateMessages(delta);
+    this.updateFinishState();
+    this.updateCamera(delta);
+    this.audio.updateEngine(this.player.speed, playerInput.throttle - playerInput.brake, this.player.nitroTimer > 0);
+  }
+
+  private readPlayerInput(): DriverInput {
+    return {
+      throttle: this.input.isDown('arrowup', 'w') ? 1 : 0,
+      brake: this.input.isDown('arrowdown', 's') ? 1 : 0,
+      steer: (this.input.isDown('arrowright', 'd') ? 1 : 0) - (this.input.isDown('arrowleft', 'a') ? 1 : 0),
+      nitro: this.input.isDown('space'),
+    };
+  }
+
+  private resolveCollisions(): void {
+    for (const car of this.cars) {
+      const result = car.collideObstacles(this.track, this.effects);
+      if (car === this.player && result === 'hit') {
+        this.audio.beep('hit');
+        this.flashMessage('Ouch! Watch the rocks.');
+      }
+      if (car === this.player && result === 'bump') this.flashMessage('Big air!');
+
+      if (car === this.player && car.collectedPickup) {
+        this.audio.beep('pickup');
+        this.flashMessage('Nitro recharged!');
+      }
+    }
+
+    for (let i = 0; i < this.cars.length; i++) {
+      for (let j = i + 1; j < this.cars.length; j++) this.cars[i].collideWith(this.cars[j], this.effects);
+    }
+  }
+
+  private updateRanks(): void {
+    const sorted = [...this.cars].sort((a, b) => b.totalProgress - a.totalProgress || b.speed - a.speed);
+    sorted.forEach((car, index) => {
+      car.rank = index + 1;
+    });
+  }
+
+  private updateMessages(delta: number): void {
+    if (this.messageTimer > 0) {
+      this.messageTimer -= delta;
+      if (this.messageTimer <= 0) this.message = '';
+    }
+  }
+
+  private updateFinishState(): void {
+    const finished = this.cars.filter((car) => car.finished).sort((a, b) => a.finishTime - b.finishTime);
+    if (!finished.length) return;
+    this.winner = finished[0].name;
+    if (this.player.finished || finished.length >= 2) {
+      this.state = 'finished';
+      this.audio.beep('finish');
+    }
+  }
+
+  private updateCamera(delta: number): void {
+    const lookX = this.player.x + this.player.vx * 0.55;
+    const lookY = this.player.y + this.player.vy * 0.55;
+    this.camera.x = lerp(this.camera.x, lookX, 1 - Math.pow(0.001, delta));
+    this.camera.y = lerp(this.camera.y, lookY, 1 - Math.pow(0.001, delta));
+    this.camera.zoom = lerp(this.camera.zoom, clamp(0.78 - this.player.speed / 950, 0.56, 0.78), 0.04);
+    this.camera.shakeX = this.effects.shake ? rand(-this.effects.shake, this.effects.shake) : 0;
+    this.camera.shakeY = this.effects.shake ? rand(-this.effects.shake, this.effects.shake) : 0;
+  }
+
+  private render(): void {
+    this.renderer.render(this.track, this.cars, this.player, this.effects, this.camera);
+    this.ui.render(this.uiData());
+  }
+
+  private uiData() {
+    return {
+      state: this.state,
+      countdown: this.countdown,
+      player: this.player,
+      track: this.track,
+      elapsed: this.raceTime,
+      message: this.message,
+      winner: this.winner,
+    };
+  }
+
+  private resetRace(): void {
+    this.track = new Track();
+    this.effects = new Effects();
+    this.raceTime = 0;
+    this.winner = '';
+    this.message = '';
+    this.cars = [
+      new Car({ name: 'You', color: '#f43f5e', accent: '#fecdd3', isPlayer: true }, this.track.startPosition(0)),
+      new Car({ name: 'Baja Bob', color: '#f59e0b', accent: '#fde68a' }, this.track.startPosition(1)),
+      new Car({ name: 'Dusty Diaz', color: '#22c55e', accent: '#bbf7d0' }, this.track.startPosition(2)),
+      new Car({ name: 'Nitro Nell', color: '#3b82f6', accent: '#bfdbfe' }, this.track.startPosition(3)),
+    ];
+    this.player = this.cars[0];
+    this.ai = [new AIController(0), new AIController(1), new AIController(2)];
+    this.camera.x = this.player.x;
+    this.camera.y = this.player.y;
+    this.state = this.state === 'menu' ? 'menu' : 'countdown';
+  }
+
+  private flashMessage(message: string): void {
+    this.message = message;
+    this.messageTimer = 1.6;
+  }
+}

package/codex-test/offroad-nitro-racer/src/game/Input.ts

@@ -0,0 +1,45 @@
+export class Input {
+  private keys = new Set<string>();
+  private pressed = new Set<string>();
+
+  constructor() {
+    window.addEventListener('keydown', (event) => {
+      const key = this.normalize(event.key);
+      if (!this.keys.has(key)) this.pressed.add(key);
+      this.keys.add(key);
+
+      if (['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', ' ', 'Space'].includes(event.key)) {
+        event.preventDefault();
+      }
+    });
+
+    window.addEventListener('keyup', (event) => {
+      this.keys.delete(this.normalize(event.key));
+    });
+
+    window.addEventListener('blur', () => {
+      this.keys.clear();
+      this.pressed.clear();
+    });
+  }
+
+  isDown(...keys: string[]): boolean {
+    return keys.some((key) => this.keys.has(this.normalize(key)));
+  }
+
+  consume(key: string): boolean {
+    const normalized = this.normalize(key);
+    if (!this.pressed.has(normalized)) return false;
+    this.pressed.delete(normalized);
+    return true;
+  }
+
+  endFrame(): void {
+    this.pressed.clear();
+  }
+
+  private normalize(key: string): string {
+    if (key === ' ') return 'space';
+    return key.toLowerCase();
+  }
+}