typescript-e2e-load-skew-flake

Answer

Root cause. The legacy goal-script drove the player with a fixed cadence: 14 jump presses spaced 500ms apart on the wall clock. The sim is a 60Hz fixed-timestep loop advanced by rAF; under host load rAF is throttled and the MAX_TICKS_PER_FRAME=5 cap means each throttled frame can only catch up ≈83ms of game time. Wall time and game time therefore diverged — 500ms of wall time could consume far less than 500ms of sim time — so the run never accumulated enough game time to reach ACT CLEAR or a HUD timer ≥ 8s, and the test flaked.

Fix. Stop driving from wall clock. Drive from sim state via the __rrDebug getters (playerX/Y/Vx/Vy, grounded, mode, gameState, timer, obstacles) in a ~120ms poll loop; trigger full-height 600ms jump holds (release past apex) on obstacle lookahead or stall escape (|vx| ≤ 0.8 on 2 consecutive samples); gate the exit on sim clock (terminal gameState or HUD timer ≥ 8), with a generous wall-clock backstop and a 90s test timeout.

// e2e/level-clear.spec.ts
import { test, expect, Page } from '@playwright/test';

const POLL_MS        = 120;   // sim-state poll cadence (not a jump cadence!)
const JUMP_HOLD_MS   = 600;   // full-height jump: key held past apex
const STALL_VX       = 0.8;   // |vx| below this x2 samples => wall-stalled
const STALL_SAMPLES  = 2;
const LOOKAHEAD_X    = 64;    // px ahead of player leading edge
const JUMP_BAND_Y    = 48;    // obstacle top must be within this band of feet
const TIMER_CLEAR    = 8;     // HUD sim timer that counts as a clear
const BACKSTOP_MS    = 80_000;// generous wall backstop (sim gate is primary)
const TEST_TIMEOUT_MS= 90_000;

interface DebugState {
  playerX: number; playerY: number;
  vx: number; vy: number;
  grounded: boolean;
  mode: string; gameState: string;
  timer: number;
  obstacles: ReadonlyArray<{ x: number; y: number; w: number; h: number }>;
}

/** Read __rrDebug once; null until the debug API is mounted. */
async function readDebug(page: Page): Promise<DebugState | null> {
  return page.evaluate(() => {
    const d = (window as any).__rrDebug;
    if (!d) return null;
    return {
      playerX: d.playerX ?? NaN, playerY: d.playerY ?? NaN,
      vx: d.vx ?? 0, vy: d.vy ?? 0,
      grounded: !!d.grounded,
      mode: d.mode ?? '', gameState: d.gameState ?? '',
      timer: typeof d.timer === 'number' ? d.timer : NaN,
      obstacles: Array.isArray(d.obstacles) ? d.obstacles : [],
    };
  });
}

/** Obstacle whose left edge is just ahead and tall enough to matter. */
function obstacleAhead(s: DebugState): boolean {
  return s.obstacles.some(
    (o) => o.x + o.w > s.playerX
      && o.x - s.playerX < LOOKAHEAD_X
      && o.y < s.playerY + JUMP_BAND_Y,
  );
}

async function steerRun(page: Page): Promise<string> {
  const wallStart = Date.now();

  // --- Phase 1: wait for sim readiness (no fixed sleeps) ---------------------
  let s = await readDebug(page);
  while (Date.now() - wallStart < BACKSTOP_MS && (!s || s.gameState !== 'PLAYING')) {
    await page.waitForTimeout(POLL_MS);
    s = await readDebug(page);
  }
  if (!s || s.gameState !== 'PLAYING') return 'NO_PLAY';

  // --- Phase 2: sim-state-driven steering loop -------------------------------
  let stallStreak = 0;
  let jumpStart = -1;              // wall timestamp of current hold (-1 = released)

  while (Date.now() - wallStart < BACKSTOP_MS) {
    s = await readDebug(page);

    // SIM-CLOCK exit gate: terminal state or HUD timer >= 8.
    if (s) {
      if (s.gameState === 'CLEAR') return 'CLEAR';
      if (s.gameState === 'GAMEOVER') return 'GAMEOVER';
      if (Number.isFinite(s.timer) && s.timer >= TIMER_CLEAR) return 'TIMER';
    }

    // Stall escape: grounded with |vx| ~ 0 across consecutive samples.
    if (s && Number.isFinite(s.vx)) {
      stallStreak = s.grounded && Math.abs(s.vx) <= STALL_VX ? stallStreak + 1 : 0;
    } else {
      stallStreak = 0;
    }

    const wantJump = !!s && (obstacleAhead(s) || stallStreak >= STALL_SAMPLES);

    // Trigger a full-height hold only if not already holding.
    if (wantJump && jumpStart < 0) {
      await page.keyboard.down('Space');
      jumpStart = Date.now();
    }

    // Release past apex: 600ms wall floor, or as soon as the sim reports
    // descending (vy > 0) so a slow-ticking sim never over-holds.
    if (jumpStart >= 0) {
      const pastApex = !!s && Number.isFinite(s.vy) && s.vy > 0;
      if (Date.now() - jumpStart >= JUMP_HOLD_MS || pastApex) {
        await page.keyboard.up('Space');
        jumpStart = -1;
      }
    }

    await page.waitForTimeout(POLL_MS);
  }

  return 'BACKSTOP'; // never saw CLEAR/TIMER on the sim clock
}

test('goal script clears the level under host load', async ({ page }) => {
  test.setTimeout(TEST_TIMEOUT_MS);
  await page.goto('/');
  const result = await steerRun(page);
  expect(['CLEAR', 'TIMER'], `run ended in ${result}`).toContain(result);
});

What changed vs. the legacy script