731 lines
28 KiB
JavaScript
731 lines
28 KiB
JavaScript
// Headless verification for Star Control Super Melee.
|
|
// node tools/verifyStarControl.js
|
|
// Exits non-zero on any failure.
|
|
//
|
|
// 1. Ship JSON schema: every entry compiles, every type resolves in the
|
|
// behavior registries, stats in sane bounds.
|
|
// 2. Toroidal math (wrap/tdelta/tmid) spot checks.
|
|
// 3. Determinism: same seed + same input script => identical state hash.
|
|
// 4. Fuzz invariants: energy/crew always in [0, max] under random inputs.
|
|
// 5. Physics fixtures: thrust cap, gravity pull, planet bounce + damage.
|
|
// 6. Weapon fixtures per pilot ship (hit registration + exact damage),
|
|
// special fixtures (point defense, glory falloff, fighters launch/dock,
|
|
// cloak vs homing, rear B.U.T.T.).
|
|
// 7. Smooth-zoom mapping: monotonic, anchored at the three UQM-style levels.
|
|
|
|
import { readFileSync } from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { dirname, join } from 'node:path';
|
|
|
|
import {
|
|
STEP_MS, ARENA_W, ARENA_H, TUNE, ZOOM,
|
|
mulberry32, wrap, tdelta, tdist, tmid, quantizeFacing, angleDelta,
|
|
compileShips, createBattle, setInput, stepMatch,
|
|
targetZoom, smoothTowards, interceptAngle,
|
|
} from '../src/games/starcontrol/StarControlLogic.js';
|
|
import { PRIMARIES, SPECIALS, PASSIVES } from '../src/games/starcontrol/StarControlShips.js';
|
|
|
|
const root = join(dirname(fileURLToPath(import.meta.url)), '..');
|
|
const shipsJson = JSON.parse(readFileSync(join(root, 'data/star-control-ships.json'), 'utf8'));
|
|
|
|
let failures = 0;
|
|
let passes = 0;
|
|
function check(name, cond, detail = '') {
|
|
if (cond) { passes += 1; return; }
|
|
failures += 1;
|
|
console.error(` FAIL ${name}${detail ? ` — ${detail}` : ''}`);
|
|
}
|
|
function section(name) { console.log(`\n== ${name}`); }
|
|
|
|
// Steps whole 24fps frames deterministically (no accumulator drift in tests).
|
|
function stepFrames(state, n, collect = false) {
|
|
const events = [];
|
|
for (let i = 0; i < n; i += 1) {
|
|
const evs = stepMatch(state, STEP_MS);
|
|
if (collect) events.push(...evs);
|
|
if (state.over) break;
|
|
}
|
|
return events;
|
|
}
|
|
|
|
const SHIPS = compileShips(shipsJson);
|
|
const keys = Object.keys(SHIPS);
|
|
|
|
function battle(aKey, bKey, seed = 7) {
|
|
const st = createBattle({ a: { def: SHIPS[aKey] }, b: { def: SHIPS[bKey] }, seed });
|
|
st.asteroids = []; // fixtures don't want random rocks in the way
|
|
return st;
|
|
}
|
|
|
|
function place(ship, x, y, facing = 0, vx = 0, vy = 0) {
|
|
ship.x = wrap(x, ARENA_W); ship.y = wrap(y, ARENA_H);
|
|
ship.px = ship.x; ship.py = ship.y;
|
|
ship.facing = facing; ship.vx = vx; ship.vy = vy;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('1. ship JSON schema');
|
|
check('ships JSON has entries', keys.length > 0);
|
|
check('credits line present (CC BY-NC-SA attribution)', /CC BY-NC-SA/.test(shipsJson.credits ?? ''));
|
|
for (const key of keys) {
|
|
const def = SHIPS[key];
|
|
check(`${key}: primary type registered`, !!PRIMARIES[def.primary.type], def.primary.type);
|
|
check(`${key}: special type registered`, !!SPECIALS[def.special.type], def.special.type);
|
|
for (const p of def.passives) check(`${key}: passive registered`, !!PASSIVES[p], p);
|
|
check(`${key}: crew/energy sane`, def.stats.maxCrew >= 1 && def.stats.maxCrew <= 42
|
|
&& def.stats.maxEnergy >= 1 && def.stats.maxEnergy <= 42);
|
|
check(`${key}: point value sane`, def.pointValue >= 1 && def.pointValue <= 30);
|
|
check(`${key}: has ai hints`, !!def.ai && typeof def.ai.preferredRange === 'number');
|
|
check(`${key}: radius derived`, def.radius > 0);
|
|
check(`${key}: turn rate derived`, def.turnPerFrame > 0);
|
|
}
|
|
check('bad ship def throws (named reason)', (() => {
|
|
try { compileShips({ ships: { junk: { name: 'X', team: 'alliance', pointValue: 1, stats: {}, primary: { type: 'nope' }, special: { type: 'nope' } } } }); return false; }
|
|
catch (e) { return /junk/.test(e.message); }
|
|
})());
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('2. toroidal math');
|
|
check('wrap into range', wrap(-10, ARENA_W) === ARENA_W - 10 && wrap(ARENA_W + 5, ARENA_W) === 5);
|
|
check('tdelta short way', tdelta(100, ARENA_W - 100, ARENA_W) === -200);
|
|
check('tdelta antisymmetry', tdelta(500, 4000, ARENA_W) === -tdelta(4000, 500, ARENA_W));
|
|
{
|
|
const m = tmid(ARENA_W - 100, 100, 100, 100);
|
|
check('tmid crosses seam', m.x === 0 || m.x === ARENA_W, `got ${m.x}`);
|
|
}
|
|
check('angleDelta wraps', Math.abs(angleDelta(0.1, Math.PI * 2 - 0.1) + 0.2) < 1e-9);
|
|
check('quantizeFacing wraps negatives', quantizeFacing(-0.01) === 0 && quantizeFacing(Math.PI) === 8);
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('3. determinism');
|
|
{
|
|
const hashOf = (st) => st.ships.map((s) => [
|
|
s.x.toFixed(4), s.y.toFixed(4), s.vx.toFixed(4), s.vy.toFixed(4),
|
|
s.facing.toFixed(4), s.crew, s.energy,
|
|
].join(',')).join('|') + `#${st.projectiles.length}`;
|
|
const run = () => {
|
|
const st = createBattle({ a: { def: SHIPS.earthling }, b: { def: SHIPS.spathi }, seed: 42 });
|
|
const rng = mulberry32(99);
|
|
let acc = '';
|
|
for (let f = 0; f < 2000 && !st.over; f += 1) {
|
|
for (const side of [0, 1]) {
|
|
setInput(st, side, {
|
|
left: rng() < 0.2, right: rng() < 0.2, thrust: rng() < 0.5,
|
|
fire: rng() < 0.3, special: rng() < 0.1,
|
|
});
|
|
}
|
|
stepMatch(st, STEP_MS);
|
|
if (f % 100 === 0) acc += hashOf(st);
|
|
}
|
|
return acc;
|
|
};
|
|
check('same seed + inputs => identical trace', run() === run());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('4. fuzz invariants (energy/crew bounds, positions in-arena)');
|
|
for (const key of keys) {
|
|
const st = createBattle({ a: { def: SHIPS[key] }, b: { def: SHIPS.urquan }, seed: 11 });
|
|
const rng = mulberry32(1234);
|
|
let ok = true;
|
|
let detail = '';
|
|
for (let f = 0; f < 5000 && !st.over; f += 1) {
|
|
for (const side of [0, 1]) {
|
|
setInput(st, side, {
|
|
left: rng() < 0.25, right: rng() < 0.25, thrust: rng() < 0.5,
|
|
fire: rng() < 0.35, special: rng() < 0.15,
|
|
});
|
|
}
|
|
stepMatch(st, STEP_MS);
|
|
for (const s of st.ships) {
|
|
if (s.energy < 0 || s.energy > s.def.stats.maxEnergy) { ok = false; detail = `${s.def.key} energy ${s.energy}`; }
|
|
if (s.crew < 0 || s.crew > s.def.stats.maxCrew) { ok = false; detail = `${s.def.key} crew ${s.crew}`; }
|
|
if (s.x < 0 || s.x >= ARENA_W || s.y < 0 || s.y >= ARENA_H) { ok = false; detail = `${s.def.key} pos ${s.x},${s.y}`; }
|
|
if (!Number.isFinite(s.x + s.y + s.vx + s.vy + s.facing)) { ok = false; detail = `${s.def.key} NaN`; }
|
|
}
|
|
if (!ok) break;
|
|
}
|
|
check(`fuzz ${key} vs urquan`, ok, detail);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('5. physics fixtures');
|
|
{
|
|
// Thrust alone never exceeds maxThrust.
|
|
const st = battle('shofixti', 'urquan');
|
|
const savedG = TUNE.PLANET_GRAVITY;
|
|
TUNE.PLANET_GRAVITY = 0;
|
|
const A = st.ships[0];
|
|
place(A, 1000, 1000, 0);
|
|
setInput(st, 0, { thrust: true });
|
|
stepFrames(st, 200);
|
|
const speed = Math.hypot(A.vx, A.vy);
|
|
check('thrust reaches maxThrust', Math.abs(speed - A.def.stats.maxThrust) < 0.6, `speed ${speed}`);
|
|
stepFrames(st, 100);
|
|
check('thrust never exceeds maxThrust', Math.hypot(A.vx, A.vy) <= A.def.stats.maxThrust + 1e-6);
|
|
TUNE.PLANET_GRAVITY = savedG;
|
|
}
|
|
{
|
|
// Gravity pulls a coasting ship toward the planet.
|
|
const st = battle('earthling', 'urquan');
|
|
const A = st.ships[0];
|
|
place(A, ARENA_W / 2 - 1500, ARENA_H / 2, 0);
|
|
const d0 = tdist(A.x, A.y, ARENA_W / 2, ARENA_H / 2);
|
|
stepFrames(st, 30);
|
|
const d1 = tdist(A.x, A.y, ARENA_W / 2, ARENA_H / 2);
|
|
check('gravity pulls ship planet-ward', d1 < d0, `${d0} -> ${d1}`);
|
|
}
|
|
{
|
|
// Planet impact costs crew (once per cooldown window) and ejects the ship.
|
|
const st = battle('urquan', 'earthling');
|
|
const A = st.ships[0];
|
|
place(A, ARENA_W / 2 - 600, ARENA_H / 2, 0, 60, 0);
|
|
const crew0 = A.crew;
|
|
let bounced = false;
|
|
for (let f = 0; f < 30 && !bounced; f += 1) {
|
|
bounced = stepFrames(st, 1, true).some((e) => e.t === 'planetBounce');
|
|
}
|
|
stepFrames(st, 3);
|
|
check('planetBounce event emitted', bounced);
|
|
check('planet bounce damages crew once', A.crew === crew0 - TUNE.PLANET_CREW_DAMAGE, `crew ${A.crew}`);
|
|
const d = tdist(A.x, A.y, ARENA_W / 2, ARENA_H / 2);
|
|
check('ship ejected from planet', d > st.planet.radius, `d ${d}`);
|
|
}
|
|
{
|
|
// Ship-ship collision: both take a knock at speed, momentum pushes apart.
|
|
const st = battle('urquan', 'earthling');
|
|
const [A, B] = st.ships;
|
|
const savedG = TUNE.PLANET_GRAVITY;
|
|
TUNE.PLANET_GRAVITY = 0;
|
|
place(A, 3000, 1000, 0, 80, 0);
|
|
place(B, 3000 + A.def.radius + B.def.radius + 90, 1000, Math.PI, -80, 0);
|
|
const crews = [A.crew, B.crew];
|
|
stepFrames(st, 20);
|
|
check('collision damages both ships', A.crew < crews[0] && B.crew < crews[1], `${A.crew},${B.crew}`);
|
|
check('collision separates ships', tdist(A.x, A.y, B.x, B.y) >= A.def.radius + B.def.radius - 1);
|
|
TUNE.PLANET_GRAVITY = savedG;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('6. weapon + special fixtures');
|
|
const savedG2 = TUNE.PLANET_GRAVITY;
|
|
TUNE.PLANET_GRAVITY = 0; // keep fixtures geometric
|
|
|
|
{
|
|
// Every pilot primary lands on a stationary hulk dead ahead, placed inside
|
|
// that weapon's actual reach (flamethrowers are short, nukes are long).
|
|
for (const key of keys) {
|
|
const st = battle(key, key === 'urquan' ? 'earthling' : 'urquan');
|
|
const [A, B] = st.ships;
|
|
const pd = A.def.primary;
|
|
const reach = pd.type === 'beam'
|
|
? pd.range * 4
|
|
: (pd.muzzleDist ?? 12) * 4 + (pd.speed ?? 0) * (pd.lifeFrames ?? 0);
|
|
const dist = Math.min(600, Math.max(220, reach * 0.6));
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000 + dist, 3000, Math.PI);
|
|
A.fx.warped = true; B.fx.warped = true; // suppress VUX-style warp-in repositioning
|
|
const crew0 = B.crew;
|
|
setInput(st, 0, { fire: true });
|
|
stepFrames(st, 90);
|
|
setInput(st, 0, { fire: false }); // charge-shot weapons launch on release
|
|
stepFrames(st, 40);
|
|
check(`${key} primary hits`, B.crew < crew0, `crew still ${B.crew} at dist ${dist}`);
|
|
}
|
|
}
|
|
{
|
|
// Exact damage: one Ur-Quan fusion bolt = 6 crew.
|
|
const st = battle('urquan', 'earthling');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2900, 3000, Math.PI);
|
|
setInput(st, 0, { fire: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { fire: false });
|
|
stepFrames(st, 40);
|
|
check('fusion bolt exact damage', B.crew === B.def.stats.maxCrew - 6, `crew ${B.crew}`);
|
|
}
|
|
{
|
|
// Homing: nuke curves onto a target off boresight; cloak defeats tracking.
|
|
const run = (cloaked) => {
|
|
const st = battle('earthling', 'ilwrath');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000 + 1200, 3000 - 900, 0);
|
|
if (cloaked) B.fx.cloaked = true;
|
|
setInput(st, 0, { fire: true });
|
|
stepFrames(st, 2);
|
|
setInput(st, 0, { fire: false });
|
|
stepFrames(st, 70);
|
|
return B.crew < B.def.stats.maxCrew;
|
|
};
|
|
check('nuke tracks an off-axis target', run(false));
|
|
check('cloak defeats nuke tracking', !run(true));
|
|
}
|
|
{
|
|
// Point defense: zaps an incoming missile before impact, costs energy.
|
|
const st = battle('earthling', 'spathi');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000, 3000 + 260, -Math.PI / 2);
|
|
// Spathi B.U.T.T. fired away from us won't reach; instead have Spathi shoot at us.
|
|
place(B, 2600, 3000, Math.PI);
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 3);
|
|
setInput(st, 1, { fire: false });
|
|
const e0 = A.energy;
|
|
let zapped = false;
|
|
for (let f = 0; f < 30 && !zapped; f += 1) {
|
|
setInput(st, 0, { special: true });
|
|
zapped = stepMatch(st, STEP_MS).some((e) => e.t === 'pdZap');
|
|
}
|
|
check('point defense zaps incoming fire', zapped);
|
|
check('point defense costs energy', A.energy < e0, `${e0} -> ${A.energy}`);
|
|
check('shot never landed', A.crew === A.def.stats.maxCrew);
|
|
}
|
|
{
|
|
// Glory device: falloff damage, kills the scout, ends the battle.
|
|
const dmgAt = (dist) => {
|
|
const st = battle('shofixti', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000 + dist, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 3);
|
|
return { dmg: B.def.stats.maxCrew - B.crew, st, A };
|
|
};
|
|
const near = dmgAt(200);
|
|
const far = dmgAt(650);
|
|
const out = dmgAt(1000);
|
|
check('glory kills the scout', !near.A.alive);
|
|
check('glory near > far damage', near.dmg > far.dmg, `${near.dmg} vs ${far.dmg}`);
|
|
check('glory out of range = 0', out.dmg === 0, `${out.dmg}`);
|
|
const expect = Math.floor((18 * (720 - 200)) / 720) + 1;
|
|
check('glory matches UQM falloff formula', near.dmg === expect, `${near.dmg} vs ${expect}`);
|
|
}
|
|
{
|
|
// Fighters: launch costs a crew member, they harass, then dock and return it.
|
|
const st = battle('urquan', 'earthling');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000 + 1500, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
check('fighter launched', st.projectiles.some((p) => p.type === 'fighter'));
|
|
check('launch costs 1 crew', A.crew === A.def.stats.maxCrew - 1);
|
|
const crewB0 = B.crew;
|
|
const evs = stepFrames(st, 500, true);
|
|
check('fighter shot at the enemy', B.crew < crewB0 || evs.some((e) => e.t === 'pdZap'));
|
|
check('fighter docked home (crew restored)', A.crew === A.def.stats.maxCrew
|
|
|| evs.some((e) => e.t === 'fighterDock'), `crew ${A.crew}`);
|
|
}
|
|
{
|
|
// B.U.T.T.: rear-launched missile homes onto a pursuer behind the Eluder.
|
|
const st = battle('spathi', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 3000, 3000, 0, 20, 0);
|
|
place(B, 3000 - 700, 3000, 0, 20, 0); // chasing from behind
|
|
const crew0 = B.crew;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
stepFrames(st, 40);
|
|
check('B.U.T.T. hits the pursuer', B.crew === crew0 - 2, `crew ${B.crew}`);
|
|
}
|
|
{
|
|
// Asteroids block shots and shatter.
|
|
const st = battle('spathi', 'urquan');
|
|
const [A] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(st.ships[1], 6000, 6000, 0);
|
|
st.asteroids.push({
|
|
id: 9999, kind: 'asteroid', x: 2400, y: 3000, px: 2400, py: 3000,
|
|
vx: 0, vy: 0, spin: 0, rot: 0, radius: TUNE.ASTEROID_RADIUS, alive: true,
|
|
});
|
|
setInput(st, 0, { fire: true });
|
|
const evs = stepFrames(st, 10, true);
|
|
check('asteroid shattered by shot', evs.some((e) => e.t === 'asteroidBreak'));
|
|
}
|
|
{
|
|
// Battle-over bookkeeping: winner declared once, loser reported.
|
|
const st = battle('shofixti', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2150, 3000, Math.PI);
|
|
setInput(st, 0, { special: true }); // glory at point blank vs 42-crew hulk: scout dies
|
|
const evs = stepFrames(st, 5, true);
|
|
check('battleOver emitted', evs.some((e) => e.t === 'battleOver'));
|
|
check('winner is the dreadnought', st.winner === 1, `winner ${st.winner}`);
|
|
check('death event for scout', evs.some((e) => e.t === 'death' && e.side === 0));
|
|
}
|
|
// ---------------------------------------------------------------------------
|
|
section('6b. special-ability fixtures (full roster)');
|
|
{
|
|
// Teleport relocates the Skiff.
|
|
const st = battle('arilou', 'urquan');
|
|
const A = st.ships[0];
|
|
place(A, 2000, 3000, 0);
|
|
const x0 = A.x;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 2);
|
|
check('teleport relocates', tdist(A.x, A.y, x0, 3000) > 400 || A.x !== x0);
|
|
}
|
|
{
|
|
// Yehat force shield blocks a fusion bolt outright.
|
|
const st = battle('yehat', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2900, 3000, 0);
|
|
place(B, 2000, 3000, 0);
|
|
A.fx.shieldFrames = 200;
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 1, { fire: false });
|
|
stepFrames(st, 40);
|
|
check('force shield blocks damage', A.crew === A.def.stats.maxCrew, `crew ${A.crew}`);
|
|
}
|
|
{
|
|
// Utwig absorption shield converts damage into battery charge.
|
|
const st = battle('utwig', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2900, 3000, 0);
|
|
place(B, 2000, 3000, 0);
|
|
A.energy = 2;
|
|
A.fx.absorbFrames = 200;
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 1, { fire: false });
|
|
stepFrames(st, 40);
|
|
check('absorption shield converts damage', A.crew === A.def.stats.maxCrew && A.energy === 8,
|
|
`crew ${A.crew} energy ${A.energy}`);
|
|
}
|
|
{
|
|
// Druuge furnace trades a crewman for a full battery.
|
|
const st = battle('druuge', 'urquan');
|
|
const A = st.ships[0];
|
|
A.energy = 3;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('furnace refills battery for 1 crew',
|
|
A.crew === A.def.stats.maxCrew - 1 && A.energy === A.def.stats.maxEnergy,
|
|
`crew ${A.crew} energy ${A.energy}`);
|
|
}
|
|
{
|
|
// Mycon regeneration: full battery -> +4 crew.
|
|
const st = battle('mycon', 'urquan');
|
|
const A = st.ships[0];
|
|
A.crew = 10;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('mycon regenerates 4 crew', A.crew === 14 && A.energy <= 1, `crew ${A.crew} energy ${A.energy}`);
|
|
}
|
|
{
|
|
// Pkunk taunt restores energy; resurrection lands in a plausible band.
|
|
const st = battle('pkunk', 'urquan');
|
|
const A = st.ships[0];
|
|
A.energy = 0;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('pkunk taunt restores energy', A.energy === 2, `energy ${A.energy}`);
|
|
let rebirths = 0;
|
|
let deaths = 0;
|
|
const N = 400;
|
|
for (let i = 0; i < N; i += 1) {
|
|
const st2 = battle('pkunk', 'urquan', 500 + i);
|
|
const P = st2.ships[0];
|
|
place(P, 2600, 3000, 0);
|
|
place(st2.ships[1], 2000, 3000, 0);
|
|
setInput(st2, 1, { fire: true });
|
|
for (let f = 0; f < 80; f += 1) {
|
|
const evs = stepFrames(st2, 1, true);
|
|
if (evs.some((e) => e.t === 'death' && e.side === 0)) { deaths += 1; break; }
|
|
if (evs.some((e) => e.t === 'resurrect' && e.side === 0)) { deaths += 1; rebirths += 1; break; }
|
|
}
|
|
}
|
|
check('pkunk resurrection ~50% (0.40-0.60 band)',
|
|
deaths >= 100 && rebirths / deaths > 0.4 && rebirths / deaths < 0.6,
|
|
`${rebirths}/${deaths}`);
|
|
}
|
|
{
|
|
// VUX limpets degrade the enemy's turn rate.
|
|
const st = battle('yehat', 'vux');
|
|
const A = st.ships[0];
|
|
A.fx.limpets = 4;
|
|
place(A, 2000, 3000, 0);
|
|
setInput(st, 0, { right: true });
|
|
stepFrames(st, 24);
|
|
const slowed = A.facing;
|
|
const st2 = battle('yehat', 'vux');
|
|
const A2 = st2.ships[0];
|
|
place(A2, 2000, 3000, 0);
|
|
setInput(st2, 0, { right: true });
|
|
stepFrames(st2, 24);
|
|
check('limpets slow turning', slowed < A2.facing * 0.6, `${slowed} vs ${A2.facing}`);
|
|
}
|
|
{
|
|
// Orz marines board and chew crew.
|
|
const st = battle('orz', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2600, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
check('marine launched costs 1 crew', A.crew === A.def.stats.maxCrew - 1);
|
|
stepFrames(st, 300);
|
|
check('marines chew enemy crew', B.crew < B.def.stats.maxCrew, `crew ${B.crew}`);
|
|
}
|
|
{
|
|
// Chenjesu DOGI drains enemy energy; shard fragments on release.
|
|
const st = battle('chenjesu', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2900, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
check('DOGI spawned', st.projectiles.some((p) => p.type === 'dogi'));
|
|
stepFrames(st, 200);
|
|
check('DOGI drained enemy energy', B.energy < B.def.stats.maxEnergy, `energy ${B.energy}`);
|
|
|
|
const st2 = battle('chenjesu', 'urquan');
|
|
place(st2.ships[0], 2000, 3000, 0);
|
|
place(st2.ships[1], 6000, 5000, Math.PI);
|
|
setInput(st2, 0, { fire: true });
|
|
stepFrames(st2, 1);
|
|
setInput(st2, 0, { fire: false });
|
|
stepFrames(st2, 2);
|
|
check('shard shatters into fragments on release',
|
|
st2.projectiles.filter((p) => p.type === 'fragment').length === 8
|
|
&& !st2.projectiles.some((p) => p.type === 'shard'));
|
|
}
|
|
{
|
|
// Chmmr zapsats orbit and shoot down incoming missiles.
|
|
const st = battle('chmmr', 'earthling');
|
|
const [A, B] = st.ships;
|
|
check('zapsats spawned at battle start', st.projectiles.filter((p) => p.type === 'zapsat').length === 3);
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 3200, 3000, Math.PI);
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 2);
|
|
setInput(st, 1, { fire: false });
|
|
const evs = stepFrames(st, 60, true);
|
|
check('zapsats defend the Avatar', A.crew === A.def.stats.maxCrew || evs.some((e) => e.t === 'pdZap'));
|
|
}
|
|
{
|
|
// Androsynth blazer: constant-speed comet, contact does 3 crew.
|
|
const st = battle('androsynth', 'earthling');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2000 + 700, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
check('blazer engaged', A.fx.blazer === true);
|
|
const crew0 = B.crew;
|
|
stepFrames(st, 40);
|
|
check('blazer contact damage', B.crew <= crew0 - 3, `crew ${B.crew}`);
|
|
}
|
|
{
|
|
// Kohr-Ah F.R.I.E.D. clears incoming ordnance.
|
|
const st = battle('kohrah', 'earthling');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 3000, 3000, Math.PI);
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 2);
|
|
setInput(st, 1, { fire: false });
|
|
stepFrames(st, 8);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 2);
|
|
check('FRIED burns off incoming missiles',
|
|
!st.projectiles.some((p) => p.alive && p.owner === 1 && p.type === 'missile'));
|
|
}
|
|
{
|
|
// Syreen song pulls crew out as floaters; the Penetrator can rescue them.
|
|
const st = battle('syreen', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2600, 3000, Math.PI);
|
|
const crewB0 = B.crew;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
const floaters = st.projectiles.filter((p) => p.type === 'crew').length;
|
|
check('song pulls crew overboard', floaters > 0 && B.crew < crewB0, `${floaters} floaters`);
|
|
}
|
|
{
|
|
// Mmrnmhrm transform swaps stats and weapon.
|
|
const st = battle('mmrnmhrm', 'urquan');
|
|
const A = st.ships[0];
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('transform costs the battery', A.energy <= 2, `energy ${A.energy}`);
|
|
check('Y-form stats active', A.fx.formIndex === 1 && A.fx.formStats.maxThrust === 50);
|
|
check('Y-form weapon active', A.fx.formPrimary.type === 'homing');
|
|
}
|
|
{
|
|
// Umgah cone destroys incoming shots; retro hop jumps backward.
|
|
const st = battle('umgah', 'earthling');
|
|
const [A, B] = st.ships;
|
|
const savedG3 = TUNE.PLANET_GRAVITY;
|
|
TUNE.PLANET_GRAVITY = 0;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2900, 3000, Math.PI);
|
|
setInput(st, 1, { fire: true });
|
|
stepFrames(st, 2);
|
|
setInput(st, 1, { fire: false });
|
|
setInput(st, 0, { fire: true });
|
|
stepFrames(st, 24);
|
|
check('cone destroys incoming missile',
|
|
!st.projectiles.some((p) => p.alive && p.owner === 1 && p.type === 'missile'));
|
|
setInput(st, 0, { fire: false });
|
|
const x0 = A.x;
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('retro hop jumps backward', tdelta(x0, A.x, ARENA_W) < -100, `dx ${tdelta(x0, A.x, ARENA_W)}`);
|
|
TUNE.PLANET_GRAVITY = savedG3;
|
|
}
|
|
{
|
|
// Slylandro probe drive: always at full speed; harvest refuels from rocks.
|
|
const st = battle('slylandro', 'urquan');
|
|
const A = st.ships[0];
|
|
stepFrames(st, 5);
|
|
check('probe always moves at max thrust',
|
|
Math.abs(Math.hypot(A.vx, A.vy) - A.def.stats.maxThrust) < 0.001);
|
|
A.energy = 0;
|
|
st.asteroids = [{
|
|
id: 777, kind: 'asteroid', x: wrap(A.x + 200, ARENA_W), y: A.y, px: A.x, py: A.y,
|
|
vx: 0, vy: 0, spin: 0, rot: 0, radius: 60, alive: true,
|
|
}];
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
check('harvest converts asteroid to energy', A.energy === 8, `energy ${A.energy}`);
|
|
}
|
|
{
|
|
// Melnorme confusion scrambles steering flag.
|
|
const st = battle('melnorme', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
place(B, 2500, 3000, Math.PI);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 1);
|
|
setInput(st, 0, { special: false });
|
|
stepFrames(st, 20);
|
|
check('confusion pulse scrambles the enemy', (B.fx.confusedFrames ?? 0) > 0);
|
|
}
|
|
{
|
|
// Thraddash afterburner lays damaging napalm.
|
|
const st = battle('thraddash', 'urquan');
|
|
const [A, B] = st.ships;
|
|
place(A, 2000, 3000, 0);
|
|
setInput(st, 0, { special: true });
|
|
stepFrames(st, 10);
|
|
const trail = st.projectiles.filter((p) => p.type === 'napalm');
|
|
check('afterburner lays napalm trail', trail.length > 0);
|
|
if (trail.length > 0) {
|
|
place(B, trail[0].x, trail[0].y, 0);
|
|
const crew0 = B.crew;
|
|
stepFrames(st, 3);
|
|
check('napalm burns the enemy', B.crew < crew0, `crew ${B.crew}`);
|
|
}
|
|
}
|
|
TUNE.PLANET_GRAVITY = savedG2;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('6c. fleets');
|
|
{
|
|
const { PRESET_FLEETS, materializeFleet, fleetPoints, validateFleet, randomFleet, aiCounterPick, FLEET_MAX } =
|
|
await import('../src/games/starcontrol/StarControlFleets.js');
|
|
for (const preset of PRESET_FLEETS) {
|
|
const m = materializeFleet(SHIPS, preset.ships);
|
|
check(`fleet "${preset.id}" fully materializes`, m.missing.length === 0, `missing ${m.missing.join(',')}`);
|
|
check(`fleet "${preset.id}" within ${FLEET_MAX}`, m.entries.length <= FLEET_MAX);
|
|
check(`fleet "${preset.id}" validates`, validateFleet(SHIPS, m.entries).ok);
|
|
}
|
|
const alliance = materializeFleet(SHIPS, PRESET_FLEETS[0].ships);
|
|
const hierarchy = materializeFleet(SHIPS, PRESET_FLEETS[1].ships);
|
|
check('default matchup point-balanced (within 10)',
|
|
Math.abs(alliance.points - hierarchy.points) <= 10,
|
|
`${alliance.points} vs ${hierarchy.points}`);
|
|
const rf = randomFleet(SHIPS, mulberry32(5), 200);
|
|
check('grab bag within budget', fleetPoints(SHIPS, rf) <= 200 && rf.length >= 1);
|
|
const pick = aiCounterPick(SHIPS, ['shofixti', 'chmmr'], 'urquan', mulberry32(9));
|
|
check('counter-pick avoids scout vs dreadnought', pick === 'chmmr', pick);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('7. smooth zoom mapping');
|
|
{
|
|
check('close anchor at short range', Math.abs(targetZoom(0) - ZOOM.CLOSE) < 1e-9);
|
|
check('med anchor between bands', Math.abs(targetZoom((ZOOM.BAND_1[1] + ZOOM.BAND_2[0]) / 2) - ZOOM.MED) < 1e-9);
|
|
check('far anchor at long range', Math.abs(targetZoom(99999) - ZOOM.FAR) < 1e-9);
|
|
let mono = true;
|
|
let prev = Infinity;
|
|
for (let d = 0; d <= 6000; d += 25) {
|
|
const z = targetZoom(d);
|
|
if (z > prev + 1e-12) mono = false;
|
|
prev = z;
|
|
}
|
|
check('zoom monotonically non-increasing with distance', mono);
|
|
check('far viewport fits arena', 1920 / ZOOM.FAR <= ARENA_W && 1080 / ZOOM.FAR <= ARENA_H);
|
|
const z1 = smoothTowards(1, 0.25, 180);
|
|
const z2 = smoothTowards(z1, 0.25, 180);
|
|
check('smoothing approaches without overshoot', z1 > 0.25 && z2 > 0.25 && z2 < z1);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
section('8. AI pilots (soak + skill gradient)');
|
|
{
|
|
const { createAI, updateAI, knobsFor } = await import('../src/games/starcontrol/StarControlAI.js');
|
|
|
|
check('knobs interpolate between anchors', (() => {
|
|
const k = knobsFor(6);
|
|
return k.reactMs < knobsFor(5).reactMs && k.reactMs > knobsFor(7).reactMs;
|
|
})());
|
|
|
|
const playBattle = (aKey, bKey, skillA, skillB, seed) => {
|
|
const st = createBattle({ a: { def: SHIPS[aKey] }, b: { def: SHIPS[bKey] }, seed });
|
|
const aiA = createAI({ skill: skillA, side: 0, seed: seed + 1 });
|
|
const aiB = createAI({ skill: skillB, side: 1, seed: seed + 2 });
|
|
let hits = 0;
|
|
while (!st.over && st.frame < 2160) { // 90 sim-seconds cap
|
|
setInput(st, 0, updateAI(aiA, st, STEP_MS));
|
|
setInput(st, 1, updateAI(aiB, st, STEP_MS));
|
|
for (const e of stepMatch(st, STEP_MS)) if (e.t === 'shipHit') hits += 1;
|
|
}
|
|
return { winner: st.over ? st.winner : 'timeout', hits, frames: st.frame };
|
|
};
|
|
|
|
let decisive = 0;
|
|
let total = 0;
|
|
let battlesWithHits = 0;
|
|
let threw = null;
|
|
try {
|
|
for (const aKey of keys) {
|
|
for (const bKey of keys) {
|
|
const r = playBattle(aKey, bKey, 5, 5, 101 + total);
|
|
total += 1;
|
|
if (r.winner === 0 || r.winner === 1) decisive += 1;
|
|
if (r.hits > 0) battlesWithHits += 1;
|
|
}
|
|
}
|
|
} catch (e) { threw = e; }
|
|
check('AI soak throws no exceptions', !threw, threw?.stack?.split('\n')[0]);
|
|
check('nearly every AI battle produced hits (>=97%)', battlesWithHits / total >= 0.97, `${battlesWithHits}/${total}`);
|
|
check('most AI battles decisive', decisive / total >= 0.6, `${decisive}/${total}`);
|
|
|
|
let hi = 0;
|
|
let games = 0;
|
|
for (let g = 0; g < 20; g += 1) {
|
|
const r = playBattle('earthling', 'earthling', 8, 2, 900 + g);
|
|
if (r.winner === 0) hi += 1;
|
|
if (r.winner === 0 || r.winner === 1) games += 1;
|
|
}
|
|
check('skill 8 beats skill 2 (mirror match)', games >= 10 && hi / games >= 0.65, `${hi}/${games}`);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
console.log(`\n${passes} checks passed, ${failures} failed`);
|
|
if (failures > 0) process.exit(1);
|