412 lines
20 KiB
JavaScript
412 lines
20 KiB
JavaScript
// Headless verifier for the Tetris Attack engine.
|
||
// node tools/verifyTetrisAttack.js
|
||
// Exits non-zero if any check fails.
|
||
import { readFileSync } from 'node:fs';
|
||
import { fileURLToPath } from 'node:url';
|
||
import { dirname, join } from 'node:path';
|
||
import {
|
||
COLS, ROWS, TUNING, mulberry32, newGame, step, trySwap, moveCursor, setRaise, advanceStage,
|
||
findMatchGroups, findClearingSwap, isSettled, panelsAboveClearLine,
|
||
loadPuzzle, solvePuzzle, resolveFully, comboBonus, chainBonus,
|
||
} from '../src/games/tetrisattack/TetrisAttackLogic.js';
|
||
|
||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||
|
||
let failures = 0;
|
||
let checks = 0;
|
||
function check(name, cond, detail = '') {
|
||
checks++;
|
||
if (!cond) { failures++; console.log(` ✗ ${name}${detail ? ' — ' + detail : ''}`); }
|
||
}
|
||
function section(t) { console.log(`\n${t}`); }
|
||
|
||
// Build a settled state from a bottom-first grid (for fixtures). Always places
|
||
// the explicit grid (via puzzle load) then retags the mode so endless/stageclear
|
||
// fixtures use the hand-authored board rather than a random fill.
|
||
function fromGrid(grid, mode = 'puzzle') {
|
||
const s = newGame({ mode: 'puzzle', puzzle: { grid, maxMoves: 20 } });
|
||
s.mode = mode;
|
||
if (mode !== 'puzzle') s.riseRate = 0; // keep fixtures still unless a test opts in
|
||
return s;
|
||
}
|
||
// Step until settled, recording the peak chain and all emitted event types.
|
||
function resolveRecord(state, rng = () => 0.5, cap = 3000) {
|
||
let peakChain = 0;
|
||
const types = new Set();
|
||
let i = 0;
|
||
while (i < cap) {
|
||
const events = step(state, rng);
|
||
for (const e of events) types.add(e.type);
|
||
peakChain = Math.max(peakChain, state.chain);
|
||
i++;
|
||
if (isSettled(state) && state.chain === 0) break;
|
||
}
|
||
return { peakChain, types, ticks: i };
|
||
}
|
||
|
||
// ── 1. Match detection ──────────────────────────────────────────────────────
|
||
section('1. Match detection');
|
||
{
|
||
const s = fromGrid(['rrr...']);
|
||
const g = findMatchGroups(s.board);
|
||
check('horizontal 3-run found', g.length === 1 && g[0].size === 3);
|
||
|
||
const s2 = fromGrid(['g.....', 'g.....', 'g.....']);
|
||
const g2 = findMatchGroups(s2.board);
|
||
check('vertical 3-run found', g2.length === 1 && g2[0].size === 3);
|
||
|
||
// L-shape merges into one group of 5
|
||
const s3 = fromGrid(['b.....', 'b.....', 'bbb...']);
|
||
const g3 = findMatchGroups(s3.board);
|
||
check('L-shape is one group of 5', g3.length === 1 && g3[0].size === 5, JSON.stringify(g3.map(x => x.size)));
|
||
|
||
const s4 = fromGrid(['ryg...']);
|
||
check('no false match', findMatchGroups(s4.board).length === 0);
|
||
}
|
||
|
||
// ── 2. Basic clear + scoring ────────────────────────────────────────────────
|
||
section('2. Clear & scoring');
|
||
{
|
||
const s = fromGrid(['rrr...']);
|
||
const before = s.score;
|
||
const rec = resolveRecord(s);
|
||
check('clear removes matched panels', s.board.every((row) => row.every((p) => p === null || p.color !== 'red')));
|
||
check('clear event fired', rec.types.has('clear'));
|
||
check('pop event fired', rec.types.has('pop'));
|
||
check('score increased by base*3', s.score - before === 3 * TUNING.BASE_PANEL, `got ${s.score - before}`);
|
||
check('comboBonus(3)=0, (4)=20', comboBonus(3) === 0 && comboBonus(4) === 20);
|
||
check('chainBonus(1)=0, (2)=50', chainBonus(1) === 0 && chainBonus(2) === 50);
|
||
}
|
||
|
||
// ── 3. Chain propagation ────────────────────────────────────────────────────
|
||
section('3. Chain propagation');
|
||
{
|
||
// Bottom RRR clears; the g above col2 falls and completes GGG (cols 2,3,4).
|
||
const s = fromGrid(['..g...', 'rrrgg.']);
|
||
const rec = resolveRecord(s);
|
||
check('chain reaches level 2', rec.peakChain >= 2, `peak ${rec.peakChain}`);
|
||
check('chainEnd fired', rec.types.has('chainEnd'));
|
||
check('board fully cleared by chain', s.board.every((row) => row.every((p) => p === null)));
|
||
}
|
||
|
||
// ── 4. Gravity: no floating panels ──────────────────────────────────────────
|
||
section('4. Gravity');
|
||
{
|
||
// A panel with empty space beneath must fall to the floor.
|
||
const s = fromGrid(['r.....', '......', '......']);
|
||
// r is at top of a 3-tall region; resolve (no match) → it should rest on floor
|
||
resolveRecord(s, () => 0.5, 200);
|
||
const bottomHasR = s.board[ROWS - 1][0]?.color === 'red';
|
||
check('lone panel falls to floor', bottomHasR, JSON.stringify(s.board.map(r => r[0]?.color ?? '.')));
|
||
// invariant: no idle panel has an empty cell directly beneath it
|
||
let floating = 0;
|
||
for (let c = 0; c < COLS; c++) for (let r = 0; r < ROWS - 1; r++) {
|
||
if (s.board[r][c] && !s.board[r + 1][c]) floating++;
|
||
}
|
||
check('no floating panels after settle', floating === 0, `${floating} floating`);
|
||
}
|
||
|
||
// ── 5. Cursor & swap ────────────────────────────────────────────────────────
|
||
section('5. Cursor & swap');
|
||
{
|
||
const s = fromGrid(['ryr...', 'yyr...', 'rryyy.'], 'endless');
|
||
// move cursor bounds
|
||
s.cursor = { row: 0, col: 0 };
|
||
moveCursor(s, 'left');
|
||
check('cursor col clamps at 0', s.cursor.col === 0);
|
||
for (let i = 0; i < 10; i++) moveCursor(s, 'right');
|
||
check('cursor col clamps at COLS-2', s.cursor.col === COLS - 2);
|
||
|
||
// a swap between two idle panels succeeds and exchanges them
|
||
const s2 = fromGrid(['rg....'], 'endless');
|
||
s2.cursor = { row: ROWS - 1, col: 0 };
|
||
const a = s2.board[ROWS - 1][0].id;
|
||
const ev = trySwap(s2);
|
||
check('swap returns event', ev && ev.type === 'swap');
|
||
check('swap exchanged cells', s2.board[ROWS - 1][1].id === a);
|
||
|
||
// cannot swap a clearing panel
|
||
const s3 = fromGrid(['rrr...'], 'endless');
|
||
step(s3, () => 0.5); // starts the clear
|
||
s3.cursor = { row: ROWS - 1, col: 0 };
|
||
check('cannot swap mid-clear', trySwap(s3) === null);
|
||
}
|
||
|
||
// ── 6. Rise & emerge ────────────────────────────────────────────────────────
|
||
section('6. Rise & row emergence');
|
||
{
|
||
const s = newGame({ mode: 'endless', rng: mulberry32(7) });
|
||
s.riseRate = 0.34; // fast for the test
|
||
const raised0 = s.rowsRaised;
|
||
const bottomBefore = s.incoming.slice();
|
||
let sawShift = false;
|
||
for (let i = 0; i < 20; i++) {
|
||
const ev = step(s, mulberry32(99 + i));
|
||
if (ev.some((e) => e.type === 'rowShift')) sawShift = true;
|
||
}
|
||
check('rows emerge as the stack rises', s.rowsRaised > raised0 && sawShift);
|
||
check('riseOffset stays in [0,1)', s.riseOffset >= 0 && s.riseOffset < 1, `${s.riseOffset}`);
|
||
}
|
||
|
||
// ── 7. Top-out / game over ──────────────────────────────────────────────────
|
||
section('7. Top-out');
|
||
{
|
||
const s = newGame({ mode: 'endless', rng: mulberry32(3) });
|
||
// fill the entire board so row 0 is occupied and nothing can clear
|
||
for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) {
|
||
s.board[r][c] = { color: 'red', id: 10000 + r * COLS + c, state: 'idle', chain: false };
|
||
}
|
||
// give it distinct colors to avoid instant clears masking the top-out
|
||
const cols = ['red', 'yellow', 'green', 'cyan', 'purple', 'blue'];
|
||
for (let r = 0; r < ROWS; r++) for (let c = 0; c < COLS; c++) s.board[r][c].color = cols[(r + c) % 6];
|
||
let over = false;
|
||
for (let i = 0; i < TUNING.PANIC_GRACE + 50 && !over; i++) {
|
||
const ev = step(s, mulberry32(1 + i));
|
||
if (ev.some((e) => e.type === 'gameOver')) over = true;
|
||
}
|
||
check('full board tops out', over && s.over);
|
||
}
|
||
|
||
// ── 8. Stage Clear boundary line ────────────────────────────────────────────
|
||
section('8. Stage Clear');
|
||
{
|
||
// The line appears once `clearLineRows` rows have risen, lands between the
|
||
// row that just emerged and the stack above it, then rides that boundary up.
|
||
const s = newGame({ mode: 'stageclear', rng: mulberry32(5), stage: { speedLevel: 1, startRows: 3, clearLineRows: 2 } });
|
||
setRaise(s, true); // rush the rise so the line arrives within the tick budget
|
||
check('no line on a fresh stage', s.clearLine === null);
|
||
|
||
let spawns = 0;
|
||
let lineAtSpawn = null;
|
||
let rowsAtSpawn = null;
|
||
let shiftsAfterSpawn = 0;
|
||
let glued = true;
|
||
let wonBeforeLine = false;
|
||
for (let i = 0; i < 4000; i++) {
|
||
const before = s.clearLine;
|
||
const events = step(s, mulberry32(100 + i));
|
||
for (const e of events) {
|
||
if (e.type === 'clearLineAppear') { spawns++; lineAtSpawn = s.clearLine; rowsAtSpawn = s.rowsRaised; }
|
||
if (e.type === 'win' && spawns === 0) wonBeforeLine = true;
|
||
if (e.type === 'rowShift' && before !== null) {
|
||
shiftsAfterSpawn++;
|
||
if (s.clearLine !== before - 1) glued = false;
|
||
}
|
||
}
|
||
if (s.over || s.won) break;
|
||
}
|
||
check('the line appears exactly once', spawns === 1, `${spawns}`);
|
||
check('the line appears after clearLineRows rows', rowsAtSpawn === 2, `${rowsAtSpawn}`);
|
||
check('the line lands under the whole stack', lineAtSpawn === ROWS - 1, `${lineAtSpawn}`);
|
||
check('no stage win before the line exists', !wonBeforeLine);
|
||
check('the line rises with the stack', glued && shiftsAfterSpawn > 0, `${shiftsAfterSpawn} shifts`);
|
||
}
|
||
{
|
||
// Clearing everything above the line wins — panels below it are irrelevant.
|
||
const s = fromGrid(['ggg...', 'rybrgb', 'brygbr', 'ybgrby'], 'stageclear');
|
||
s.clearLine = ROWS - 3;
|
||
check('objective counts only panels above the line', panelsAboveClearLine(s) === 3, `${panelsAboveClearLine(s)}`);
|
||
let won = false;
|
||
for (let i = 0; i < 200 && !won; i++) {
|
||
if (step(s, mulberry32(50 + i)).some((e) => e.type === 'win')) won = true;
|
||
}
|
||
check('clearing above the line wins the stage', won && s.won);
|
||
check('nothing remains above the line on win', panelsAboveClearLine(s) === 0);
|
||
let below = 0;
|
||
for (let r = s.clearLine; r < ROWS; r++) for (const p of s.board[r]) if (p) below++;
|
||
check('panels below the line survive the win', below === 18, `${below}`);
|
||
}
|
||
{
|
||
// Same board with no line yet: the stage can never be won.
|
||
const s = fromGrid(['ggg...', 'rybrgb'], 'stageclear');
|
||
let won = false;
|
||
for (let i = 0; i < 300 && !won; i++) {
|
||
if (step(s, mulberry32(9 + i)).some((e) => e.type === 'win')) won = true;
|
||
}
|
||
check('an emptied board without a line does not win', !won && !s.won);
|
||
}
|
||
|
||
// ── 8b. Stage rounds (5 stages per character, same board) ───────────────────
|
||
section('8b. Stage rounds');
|
||
{
|
||
const stageOpts = { speedLevel: 2, startRows: 4, clearLineRows: 2, stageNumber: 1, speedStep: 0.2 };
|
||
const s = newGame({ mode: 'stageclear', rng: mulberry32(11), stage: stageOpts });
|
||
check('a round opens on stage 1', s.stage === 1 && s.speed === 2);
|
||
|
||
// stage 4 of the same round starts faster than stage 1 but keeps the round level
|
||
const later = newGame({ mode: 'stageclear', rng: mulberry32(11), stage: { ...stageOpts, stageNumber: 4 } });
|
||
check('a later stage starts faster', later.riseRate > s.riseRate && later.stage === 4);
|
||
check('the round level is unchanged by the stage', later.level === s.level, `${later.level}`);
|
||
|
||
// run until the line appears, then hand it a cleared objective
|
||
setRaise(s, true);
|
||
for (let i = 0; i < 4000 && s.clearLine === null; i++) step(s, mulberry32(200 + i));
|
||
check('stage 1 got its line', s.clearLine !== null);
|
||
for (let r = 0; r < s.clearLine; r++) for (let c = 0; c < COLS; c++) s.board[r][c] = null;
|
||
let won = false;
|
||
for (let i = 0; i < 60 && !won; i++) {
|
||
if (step(s, mulberry32(300 + i)).some((e) => e.type === 'win')) won = true;
|
||
}
|
||
check('emptying above the line ends stage 1', won && s.won);
|
||
|
||
const idsBefore = s.board.map((row) => row.map((p) => p?.id ?? 0).join(',')).join('|');
|
||
const rateBefore = s.riseRate;
|
||
const scoreBefore = s.score;
|
||
const rowsAtAdvance = s.rowsRaised;
|
||
advanceStage(s, { speedStep: 0.2 });
|
||
check('advancing resumes play on stage 2', !s.won && s.stage === 2);
|
||
check('advancing keeps the whole stack', s.board.map((row) => row.map((p) => p?.id ?? 0).join(',')).join('|') === idsBefore);
|
||
check('advancing keeps the score', s.score === scoreBefore);
|
||
check('advancing clears the old line', s.clearLine === null);
|
||
check('advancing speeds up the rise', s.riseRate > rateBefore && Math.abs(s.speed - 2.2) < 1e-9, `speed ${s.speed}`);
|
||
check('advancing re-arms the line', s.clearLineAt === rowsAtAdvance + 2, `${s.clearLineAt}`);
|
||
|
||
// and the next line really does show up, clearLineRows further on
|
||
let respawned = false;
|
||
let rowsAtRespawn = null;
|
||
for (let i = 0; i < 4000 && !respawned && !s.over; i++) {
|
||
if (step(s, mulberry32(500 + i)).some((e) => e.type === 'clearLineAppear')) {
|
||
respawned = true;
|
||
rowsAtRespawn = s.rowsRaised;
|
||
}
|
||
}
|
||
check('stage 2 gets a fresh line', respawned && s.clearLine === ROWS - 1);
|
||
check('the fresh line waits clearLineRows rows', rowsAtRespawn === rowsAtAdvance + 2, `${rowsAtRespawn} vs ${rowsAtAdvance}`);
|
||
}
|
||
|
||
// ── 9. Puzzle bank ──────────────────────────────────────────────────────────
|
||
section('9. Puzzle bank');
|
||
{
|
||
const bankPath = join(__dirname, '..', 'data', 'tetrisattack-puzzles.json');
|
||
const bank = JSON.parse(readFileSync(bankPath, 'utf8'));
|
||
check('bank has puzzles', bank.puzzles.length >= 12, `${bank.puzzles.length}`);
|
||
let solvable = 0;
|
||
let optimal = 0;
|
||
for (const p of bank.puzzles) {
|
||
const sol = solvePuzzle({ grid: p.grid, maxMoves: p.maxMoves }, () => 0.5);
|
||
if (sol) {
|
||
solvable++;
|
||
if (sol.length <= p.maxMoves) optimal++;
|
||
// apply the solution and confirm the board empties
|
||
const s = newGame({ mode: 'puzzle', puzzle: { grid: p.grid, maxMoves: p.maxMoves } });
|
||
for (const mv of sol) { s.cursor = { row: mv.row, col: mv.col }; trySwap(s); resolveFully(s, () => 0.5); }
|
||
const empty = s.board.every((row) => row.every((c) => c === null));
|
||
if (!empty) { failures++; checks++; console.log(` ✗ puzzle ${p.id} solution did not empty board`); }
|
||
else checks++;
|
||
}
|
||
}
|
||
check('every puzzle is solvable', solvable === bank.puzzles.length, `${solvable}/${bank.puzzles.length}`);
|
||
check('every puzzle solvable within maxMoves', optimal === bank.puzzles.length, `${optimal}/${bank.puzzles.length}`);
|
||
}
|
||
|
||
// ── 10. Determinism ─────────────────────────────────────────────────────────
|
||
section('10. Determinism');
|
||
{
|
||
const boardHash = (s) => s.board.map((row) => row.map((p) => (p ? p.color[0] : '.')).join('')).join('|');
|
||
const run = (seed) => {
|
||
const rng = mulberry32(seed);
|
||
const s = newGame({ mode: 'endless', rng });
|
||
const trace = [];
|
||
for (let i = 0; i < 400; i++) {
|
||
if (i % 5 === 0) { const mv = findClearingSwap(s); if (mv) { s.cursor = { row: mv.row, col: mv.col }; trySwap(s); } }
|
||
step(s, rng);
|
||
trace.push(`${s.score}:${boardHash(s)}`);
|
||
}
|
||
return trace.join(',');
|
||
};
|
||
check('seeded runs are identical', run(12345) === run(12345));
|
||
check('different seeds differ', run(12345) !== run(999));
|
||
}
|
||
|
||
// ── 11. Monte-carlo self-play (invariants) ──────────────────────────────────
|
||
section('11. Self-play invariants');
|
||
{
|
||
let games = 0, totalTicks = 0, gameOvers = 0, maxScore = 0, invariantBreaks = 0;
|
||
for (let g = 0; g < 40; g++) {
|
||
const seed = 1000 + g;
|
||
const rng = mulberry32(seed);
|
||
const s = newGame({ mode: 'endless', rng });
|
||
let lastScore = 0;
|
||
for (let t = 0; t < 1500 && !s.over; t++) {
|
||
// occasionally act: make a clearing swap when one exists
|
||
if (t % 5 === 0) {
|
||
const mv = findClearingSwap(s);
|
||
if (mv) { s.cursor = { row: mv.row, col: mv.col }; trySwap(s); }
|
||
}
|
||
step(s, rng);
|
||
totalTicks++;
|
||
// invariant: score never decreases
|
||
if (s.score < lastScore) invariantBreaks++;
|
||
lastScore = s.score;
|
||
// invariant: cursor in bounds
|
||
if (s.cursor.row < 0 || s.cursor.row >= ROWS || s.cursor.col < 0 || s.cursor.col > COLS - 2) invariantBreaks++;
|
||
// invariant: when fully settled, no floating idle panels
|
||
if (isSettled(s)) {
|
||
for (let c = 0; c < COLS; c++) for (let r = 0; r < ROWS - 1; r++) {
|
||
if (s.board[r][c] && s.board[r][c].state === 'idle' && !s.board[r + 1][c]) invariantBreaks++;
|
||
}
|
||
}
|
||
}
|
||
games++;
|
||
if (s.over) gameOvers++;
|
||
maxScore = Math.max(maxScore, s.score);
|
||
}
|
||
check('self-play produced no invariant breaks', invariantBreaks === 0, `${invariantBreaks} breaks`);
|
||
check('self-play scored points', maxScore > 0, `max ${maxScore}`);
|
||
console.log(` (ran ${games} games, ${totalTicks} ticks, ${gameOvers} top-outs, peak score ${maxScore})`);
|
||
}
|
||
|
||
// ── 12. Stage Clear soak (every shipped round must be beatable) ─────────────
|
||
section('12. Stage Clear soak');
|
||
{
|
||
const cfg = JSON.parse(readFileSync(join(__dirname, '..', 'data', 'tetrisattack.json'), 'utf8'));
|
||
const rounds = cfg.stageClear?.rounds ?? [];
|
||
const perRound = cfg.stageClear?.stagesPerRound;
|
||
const speedStep = cfg.stageClear?.stageSpeedStep;
|
||
// dialog is authored as arrays so each friend can say something different
|
||
const linesOk = (v) => Array.isArray(v) && v.length > 0 && v.every((l) => typeof l === 'string' && l.trim());
|
||
check('every round is fully configured', rounds.every((r) => (
|
||
Number.isInteger(r.clearLineRows) && Number.isInteger(r.startRows) && Number.isInteger(r.speedLevel)
|
||
&& r.characterId && linesOk(r.introLines) && linesOk(r.winLines) && linesOk(r.loseLines))));
|
||
check('the ladder is 6 rounds × 5 stages', rounds.length === 6 && perRound === 5, `${rounds.length}×${perRound}`);
|
||
// the per-stage ramp must not overtake the next character's opening stage
|
||
const lastStageSpeed = (r) => r.speedLevel + (perRound - 1) * speedStep;
|
||
check('the difficulty ramp stays monotonic',
|
||
rounds.every((r, i) => i === rounds.length - 1 || lastStageSpeed(r) <= rounds[i + 1].speedLevel),
|
||
`step ${speedStep}`);
|
||
let lineless = 0;
|
||
const won = [];
|
||
for (const round of rounds) {
|
||
let wins = 0;
|
||
for (let g = 0; g < 3; g++) {
|
||
const rng = mulberry32(7000 + g);
|
||
const s = newGame({
|
||
mode: 'stageclear',
|
||
stage: { speedLevel: round.speedLevel, startRows: round.startRows, clearLineRows: round.clearLineRows },
|
||
rng,
|
||
});
|
||
for (let t = 0; t < 20000 && !s.over && !s.won; t++) {
|
||
if (t % 5 === 0) {
|
||
const mv = findClearingSwap(s);
|
||
if (mv) { s.cursor = { row: mv.row, col: mv.col }; trySwap(s); }
|
||
}
|
||
step(s, rng);
|
||
}
|
||
if (s.won) wins++;
|
||
if (s.clearLine === null) lineless++;
|
||
}
|
||
won.push(`${round.name} ${wins}/3`);
|
||
}
|
||
// The line must always show up before the stack tops out — otherwise the
|
||
// round has no reachable objective at all. (Winning is a different bar: the
|
||
// greedy 1-ply player only beats the first two rounds, which was equally true
|
||
// of the old clear-the-whole-starting-stack rule.)
|
||
check('every soak game saw its CLEAR line appear', lineless === 0, `${lineless} without a line`);
|
||
check('the opening rounds are beatable by a greedy player', won.slice(0, 2).every((w) => !w.endsWith('0/3')), won.slice(0, 2).join(', '));
|
||
console.log(` (greedy wins — ${won.join(', ')})`);
|
||
}
|
||
|
||
// ── Summary ─────────────────────────────────────────────────────────────────
|
||
console.log(`\n${failures === 0 ? '✓ ALL PASSED' : '✗ FAILURES'} — ${checks - failures}/${checks} checks passed`);
|
||
process.exit(failures ? 1 : 0);
|