cabinwandClaude Opus 5
4c4c250511
No level in this project is more than a third pieces — 13% to 28% across the shipping fifty, and the thousand-level set that preceded it peaks at 32% with exactly one level above 30%. Clearing a full board is the satisfying part of a clearing game, and it has never been on offer. It was not a design choice. deadTurnAudit walks the reachable state space with a 20000-state budget, and the endgame gate read its answer. Past about eleven pieces that budget is gone long before the walk reaches any state with three pieces left, so the audit returned `endgameMinOpen: null` — and the gate, written `endgameMinOpen >= 2`, compared null and got false. Every denser level was thrown out for a bad endgame that was never looked at. `exhausted` was right there in the audit's return value and nothing consulted it. Endgames are now enumerated outright rather than walked to: C(26,3) is 2600 subsets, so it finishes on any board this game will ever have. The statistic is the SHARE of endgames that are tight, not the minimum over them, because a minimum over more subsets falls for arithmetic alone — the same confound that made doubleDead look eight times worse for deep levels when the rate was 2% against 5%. By share, crowded boards are the better ones: worst 0.33% against 1.73% for sparse. With the gate measuring something, density inverts. At eight pieces per orientation: 44% density, 18 of 23 candidates passing the whole chain, and not one failing the dead-turn gate. At two: 19% density, 9 of 23, with eleven failing on dead turns. perTurn becomes a swept dial, and the hard piece ceiling that truncated the placement schedule regardless of it is gone. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
173 lines
12 KiB
JavaScript
173 lines
12 KiB
JavaScript
#!/usr/bin/env node
|
||
// D5 (three-turn) construction prototype. Sweeps route families and seeds,
|
||
// grows each chain lock into a full level, and writes a small playable set.
|
||
// Usage: node scripts/prototype-d5.mjs [--seeds=8] [--target=12] [--keep=18] [--out=levels/prototypes/d5.json]
|
||
import { mkdirSync, writeFileSync } from 'node:fs';
|
||
import { dirname, resolve } from 'node:path';
|
||
import { Game, random } from '../src/core.js';
|
||
import { createRouteBoard, ROUTE_FAMILIES } from '../src/route-grammar.js';
|
||
import { createDeepLock, growDeepLevel, deepLevelStats, deepLevelKey, deadTurnAudit, contrastStats, showStats, openingShowFloor } from '../src/deep-lock.js';
|
||
|
||
const args = Object.fromEntries(process.argv.slice(2).map(a => { const [k, v] = a.replace(/^--/, '').split('='); return [k, v ?? true]; }));
|
||
const SEEDS = Number(args.seeds ?? 8), TARGET = Number(args.target ?? 12), KEEP = Number(args.keep ?? 18);
|
||
// Seeds are independent, so a wide sweep shards across cores by seed range.
|
||
const SEED_FROM = Number(args.seedFrom ?? 0);
|
||
const OUT = resolve(args.out ?? 'levels/prototypes/d5.json');
|
||
// 91-cell boards stay out by default: they are a readability problem, not a difficulty band.
|
||
const RADII = String(args.radii ?? '3,4').split(',').map(Number);
|
||
const MIN_PIECES = Number(args.minPieces ?? 8);
|
||
const DEPTHS = String(args.depths ?? '3,4,5,6').split(',').map(Number);
|
||
// How many pieces each orientation may hold. It is the density dial: the
|
||
// schedule is depth × perTurn placements, so perTurn 2 could never build a board
|
||
// more than a fifth pieces no matter what `target` said. Swept, so the pool
|
||
// carries both sparse and crowded boards to choose between.
|
||
const PER_TURNS = String(args.perTurns ?? args.perTurn ?? '2,5,8').split(',').map(Number);
|
||
const CAP = args.cap === undefined ? null : Number(args.cap);
|
||
const SHOWCASE = Number(args.showcase ?? 2);
|
||
// How leftover ports are paired. 'straight' was the only behaviour and it is
|
||
// what made boards read as a grid of long lines crossing everywhere.
|
||
const FILL = String(args.fill ?? 'curve');
|
||
|
||
// Random player: taps a random piece; after three blocked taps in a row, turns randomly.
|
||
function monkeyActionsPerPiece(level, runs = 8) {
|
||
let total = 0;
|
||
for (let run = 0; run < runs; run++) {
|
||
const rng = random(4242 + run * 31), game = new Game(level);
|
||
let actions = 0, streak = 0;
|
||
while (!game.won && !game.lost && actions < 800) {
|
||
if (streak >= 3) { game.rotate(rng() < .5 ? 1 : -1); actions++; streak = 0; continue; }
|
||
const tile = game.tiles[Math.floor(rng() * game.tiles.length)];
|
||
const result = game.tap(tile.id); actions++;
|
||
if (result.status === 'exit') streak = 0; else streak++;
|
||
}
|
||
total += game.won ? actions / level.tiles.length : 999;
|
||
}
|
||
return total / runs;
|
||
}
|
||
|
||
const started = Date.now();
|
||
const rows = [], seen = new Set();
|
||
const yieldTable = {};
|
||
for (const { id: family } of ROUTE_FAMILIES) for (const radius of RADII) {
|
||
const cellKey = `${family}/r${radius}`;
|
||
yieldTable[cellKey] = { locks: 0, grown: 0, seeds: SEEDS };
|
||
for (let seed = SEED_FROM; seed < SEED_FROM + SEEDS; seed++) {
|
||
const base = createRouteBoard(seed, { family, radius, fill: FILL });
|
||
const lock = createDeepLock(base, { seed, maxChecks: 600000 });
|
||
if (!lock) continue;
|
||
yieldTable[cellKey].locks++;
|
||
// Sweep depth: each extra orientation populated is one more turn the
|
||
// player must take, and each of those turns has pieces waiting.
|
||
for (const depth of DEPTHS) for (const PER_TURN of PER_TURNS) {
|
||
// A hard piece ceiling, from when crowded boards could not pass the endgame
|
||
// gate anyway. It truncated the placement schedule, so raising perTurn did
|
||
// nothing while it stood. Density is now a dial (perTurn), not a limit.
|
||
const cap = CAP;
|
||
const grown = growDeepLevel(base, lock, { seed, depth, perTurn: PER_TURN, target: cap, showcase: SHOWCASE });
|
||
const level = grown.level;
|
||
if (grown.solution.rotations < 3) continue;
|
||
const signature = deepLevelKey(level);
|
||
if (seen.has(signature)) continue;
|
||
seen.add(signature);
|
||
yieldTable[cellKey].grown++;
|
||
const stats = deepLevelStats(level);
|
||
const audit = deadTurnAudit(level);
|
||
const contrast = contrastStats(level);
|
||
const show = showStats(level);
|
||
if (!show) continue;
|
||
const apt = monkeyActionsPerPiece(level);
|
||
level.prototype = { family, radius, seed, depth, perTurn: PER_TURN, cap, lock: { hero: lock.hero.id, heroBends: lock.heroRoute.bends, search: lock.search }, placements: grown.placements, rejected: grown.rejected, stats, audit, contrast, show, monkeyActionsPerPiece: apt };
|
||
level.id = `proto-d5-${family}-r${radius}-s${seed}-d${depth}-p${PER_TURN}`;
|
||
rows.push({ level, stats, audit, contrast, show, apt, family, radius, seed, depth });
|
||
}
|
||
}
|
||
}
|
||
|
||
// A bare four-piece lock is 100% locked by definition; only fully grown levels
|
||
// count. The playable set also refuses what reads as "unsolvable": a fully
|
||
// locked opening, a first turn that only works one way, or any stuck state
|
||
// where neither adjacent orientation opens anything.
|
||
const med = arr => { const s = [...arr].sort((a, b) => a - b); return s.length ? s[Math.floor(s.length / 2)] : NaN; };
|
||
const grownEnough = rows.filter(r => r.stats.pieces >= MIN_PIECES);
|
||
// The endgame gate. It used to demand a minimum over reachable endgames, read
|
||
// off the same breadth search that counts dead turns — and on a crowded board
|
||
// that search never reaches an endgame, so it answered null and the comparison
|
||
// rejected the level for an endgame nobody had measured. Now the endgames are
|
||
// enumerated outright and the gate is the SHARE that are tight (one orientation
|
||
// or none). A minimum over more subsets falls for arithmetic reasons; the share
|
||
// does not, and by share the crowded boards are the better ones — worst 0.33%
|
||
// against 1.73% for the sparse.
|
||
const MAX_TIGHT_SHARE = Number(args.maxTightShare ?? 0.005);
|
||
const MIN_RELEASE = Number(args.minRelease ?? 2);
|
||
const MIN_CONTRAST = Number(args.minContrast ?? 12);
|
||
// Expressed at the speed it was calibrated at (120ms per unit) and scaled to
|
||
// whatever the speed dial is now, so re-tuning motion does not quietly reject
|
||
// levels that were fine. See openingShowFloor in deep-lock.
|
||
const MIN_OPENING_SHOW = openingShowFloor(Number(args.minOpeningShow ?? 800));
|
||
const MIN_OPENING_CHOICES = Number(args.minOpeningChoices ?? 3);
|
||
const MIN_CRUISES = Number(args.minCruises ?? 3);
|
||
// Rotation count is deliberately not capped: turning is free and it is the
|
||
// point of the game. What has to hold is that every turn pays out (minRelease),
|
||
// that no turn is a punishment (endgameMinOpen, firstTurnDirections), and that
|
||
// pieces actually swing between hopeless and trivial (contrast).
|
||
const playable = grownEnough.filter(r => r.audit.unsolvable === 0 && r.stats.firstTurnDirections === 2
|
||
&& r.stats.lockedShare <= .9 && r.audit.endgameTightShare <= MAX_TIGHT_SHARE
|
||
&& r.stats.minRelease >= MIN_RELEASE && r.contrast.contrast >= MIN_CONTRAST
|
||
// The show is the payout. An opening that offers two rim pieces and a 0.3s
|
||
// hop gives a casual player nothing to enjoy before the thinking starts.
|
||
&& r.show.openingChoices >= MIN_OPENING_CHOICES
|
||
&& r.show.openingBestMs >= MIN_OPENING_SHOW
|
||
&& r.show.cruises >= MIN_CRUISES);
|
||
// Locked-share used to sort first and highest, which is backwards for a casual
|
||
// player: it rewards an opening where nothing can be done. Rank by what the
|
||
// player gets — a show up front, pieces that swing from hopeless to trivial,
|
||
// and turns that pay out — and treat lock depth as a tiebreak only.
|
||
playable.sort((a, b) => (b.show.openingBestMs - a.show.openingBestMs)
|
||
|| (b.contrast.contrast - a.contrast.contrast)
|
||
|| (b.show.cruises - a.show.cruises)
|
||
|| (a.audit.doubleDead - b.audit.doubleDead));
|
||
const g1 = grownEnough.filter(r => r.stats.firstTurnDirections === 2);
|
||
const g2 = g1.filter(r => r.stats.lockedShare <= .9);
|
||
const g3 = g2.filter(r => r.audit.unsolvable === 0);
|
||
const g4 = g3.filter(r => r.audit.endgameTightShare <= MAX_TIGHT_SHARE);
|
||
const g5 = g4.filter(r => r.stats.minRelease >= MIN_RELEASE);
|
||
console.log(`\n【门槛】长成 ${grownEnough.length} → 首转双向 ${g1.length} → 锁住≤90% ${g2.length} → 无不可解态 ${g3.length} → 终局紧局≤${(MAX_TIGHT_SHARE*100).toFixed(1)}% ${g4.length} → 每转释放≥${MIN_RELEASE} ${g5.length} → 反差≥${MIN_CONTRAST} ${playable.length}`);
|
||
const g6 = g5.filter(r => r.contrast.contrast >= MIN_CONTRAST);
|
||
const g7 = g6.filter(r => r.show.openingChoices >= MIN_OPENING_CHOICES);
|
||
const g8 = g7.filter(r => r.show.openingBestMs >= MIN_OPENING_SHOW);
|
||
console.log(` → 开局可点≥${MIN_OPENING_CHOICES} ${g7.length} → 开局演出≥${(MIN_OPENING_SHOW / 1000).toFixed(2)}s ${g8.length} → 长巡游≥${MIN_CRUISES} ${playable.length}`);
|
||
console.log(`【候选池】旋转深度 ${JSON.stringify(playable.reduce((m, r) => (m[r.stats.rotations] = (m[r.stats.rotations] || 0) + 1, m), {}))}`);
|
||
console.log(` 反差 中位 ${med(playable.map(r => r.contrast.contrast)).toFixed(1)} · 家族 ${JSON.stringify(playable.reduce((m, r) => (m[r.family] = (m[r.family] || 0) + 1, m), {}))}`);
|
||
const KEEP_ALL = String(args.keep) === 'all';
|
||
const kept = [];
|
||
const perFamily = {};
|
||
for (const row of playable) {
|
||
if (!KEEP_ALL) {
|
||
perFamily[row.family] = (perFamily[row.family] || 0);
|
||
if (perFamily[row.family] >= Math.ceil(KEEP / ROUTE_FAMILIES.length) + 1) continue;
|
||
perFamily[row.family]++;
|
||
}
|
||
kept.push(row);
|
||
if (!KEEP_ALL && kept.length >= KEEP) break;
|
||
}
|
||
|
||
const pad = (v, w) => String(v).padStart(w);
|
||
console.log(`D5 三转构造原型 · ${ROUTE_FAMILIES.length} 形态 × ${RADII.length} 尺寸 × ${SEEDS} 种子 · ${((Date.now() - started) / 1000).toFixed(1)} s`);
|
||
console.log('\n【产出率】形态/尺寸 找到锁 长成 R=3 关');
|
||
for (const [k, v] of Object.entries(yieldTable)) console.log(' ' + k.padEnd(18) + pad(v.locks, 5) + '/' + v.seeds + pad(v.grown, 9) + '/' + v.seeds);
|
||
const medAll = rows.map(r => r.stats);
|
||
console.log(`\n【全部 ${rows.length} 个 R≥3 关卡】`);
|
||
console.log(` 旋转次数分布: ${JSON.stringify(medAll.reduce((m, s) => (m[s.rotations] = (m[s.rotations] || 0) + 1, m), {}))}`);
|
||
console.log(` 锁住占比（首转时剩余）中位 ${(med(medAll.map(s => s.lockedShare)) * 100).toFixed(0)}% （v0.5 现状中位 22%）`);
|
||
console.log(` 每次旋转最少释放 ≥2 枚的关: ${medAll.filter(s => s.minRelease >= 2).length}/${medAll.length}`);
|
||
console.log(` 首转只有一侧能开路的关: ${medAll.filter(s => s.firstTurnDirections === 1).length}/${medAll.length}`);
|
||
console.log(` 猴子 动作/棋子 中位 ${med(rows.map(r => r.apt)).toFixed(2)} （v0.5 全库 1.67 · v0.4 手作 3.42）`);
|
||
console.log(`\n【写入 ${kept.length} 关】`);
|
||
console.log(' id 格 枚 R 锁住% 每转释放 首转方向 双向死转态 最长盲转 终局路口 猴子APT hero弯');
|
||
for (const { level, stats, audit, apt } of kept) console.log(' ' + level.id.padEnd(36) + pad(level.cells.length, 3) + pad(stats.pieces, 4) + pad(stats.rotations, 3) + pad((stats.lockedShare * 100).toFixed(0) + '%', 7) + ' ' + stats.releasePerTurn.join('/').padEnd(12) + pad(stats.firstTurnDirections === 1 ? '单向' : '双向', 6) + pad(audit.doubleDead, 10) + pad(audit.maxDeadTurns, 9) + pad(audit.endgameMinOpen, 9) + pad(apt.toFixed(2), 9) + pad(level.prototype.lock.heroBends, 7));
|
||
console.log('\n 「双向死转态」= 可达的卡住状态里，左右各转一次都打不开任何棋子的状态数；「最长盲转」= 从某个可达卡住态朝错误方向连转、遇到第一个有效朝向前经过的空朝向数。');
|
||
|
||
mkdirSync(dirname(OUT), { recursive: true });
|
||
writeFileSync(OUT, JSON.stringify({ generated: 'prototype-d5', version: 1, options: { seeds: SEEDS, target: TARGET, radii: RADII }, summary: { candidates: rows.length, kept: kept.length, yieldTable }, levels: kept.map(r => r.level) }, null, 1));
|
||
console.log(`\n已写入 ${OUT}`);
|