Spaces:
Paused
Paused
| /* ============================================================ | |
| Guards for tools/duelCore.js — the fairness-critical "run one duel match" primitive extracted | |
| out of tools/ailab.js (docs/competitions-and-elo.md Phase 1) so a browser Worker can import it | |
| in a later stage without pulling in ailab.js's CLI/printing/search/leaderboard code. | |
| tools/ailab.js's own test/ailab.test.js already exercises pinnedDuelDials/the match runner | |
| EXHAUSTIVELY through runDuel/runSwappedDuel/runDuelBrackets — fairness across sides, difficulty | |
| pinning, determinism, override isolation — and stays the safety net proving the extraction | |
| didn't change any of that observable behaviour. This file adds direct, ISOLATED coverage of the | |
| primitive itself, imported straight from tools/duelCore.js, never through tools/ailab.js. | |
| ============================================================ */ | |
| import { test } from "node:test"; | |
| import assert from "node:assert/strict"; | |
| import { readFileSync } from "node:fs"; | |
| import { pinnedDuelDials, duelSeed, runDuelMatch } from "../tools/duelCore.js"; | |
| import { DIFFICULTY_OPTIONS } from "../engine/aiDifficulty.js"; | |
| import { STRATEGIES } from "../engine/aiStrategy.js"; | |
| /* ---------- pinnedDuelDials ---------- */ | |
| test("pinnedDuelDials reads apm/micro straight off the named DIFFICULTY_OPTIONS row", () => { | |
| for (const opt of DIFFICULTY_OPTIONS) { | |
| assert.deepEqual(pinnedDuelDials(opt.mult), { difficulty: opt.mult, apm: opt.aiApm, micro: !!opt.aiMicro }, | |
| `difficulty "${opt.mult}" must echo its own row's dials`); | |
| } | |
| }); | |
| test("pinnedDuelDials normalizes an unknown/typo'd difficulty to medium's dials AND label", () => { | |
| const medium = DIFFICULTY_OPTIONS.find(o => o.mult === "medium"); | |
| const dials = pinnedDuelDials("totallyBogusTypo"); | |
| assert.deepEqual(dials, { difficulty: "medium", apm: medium.aiApm, micro: !!medium.aiMicro }, | |
| "an unrecognised difficulty must fall back to medium's own dials, and REPORT medium -- not echo the garbage input"); | |
| }); | |
| /* ---------- duelSeed ---------- */ | |
| test("duelSeed is deterministic: identical inputs produce the identical seed", () => { | |
| const a = duelSeed(1, "ferros", "medium", "Alpha", "Beta", 0); | |
| const b = duelSeed(1, "ferros", "medium", "Alpha", "Beta", 0); | |
| assert.equal(a, b); | |
| assert.equal(typeof a, "number"); | |
| }); | |
| test("duelSeed sorts the two candidate names into the hash, so a pair draws the identical map regardless of argument order", () => { | |
| const forward = duelSeed(1, "ferros", "medium", "Alpha", "Beta", 0); | |
| const backward = duelSeed(1, "ferros", "medium", "Beta", "Alpha", 0); | |
| assert.equal(forward, backward, "duelSeed(a,b,...) and duelSeed(b,a,...) must draw the same map"); | |
| }); | |
| test("duelSeed genuinely varies with world, difficulty, replicate, and base seed", () => { | |
| const base = duelSeed(1, "ferros", "medium", "Alpha", "Beta", 0); | |
| assert.notEqual(base, duelSeed(1, "korrath", "medium", "Alpha", "Beta", 0), "world must vary the seed"); | |
| assert.notEqual(base, duelSeed(1, "ferros", "hard", "Alpha", "Beta", 0), "difficulty must vary the seed"); | |
| assert.notEqual(base, duelSeed(1, "ferros", "medium", "Alpha", "Beta", 1), "replicate must vary the seed"); | |
| assert.notEqual(base, duelSeed(2, "ferros", "medium", "Alpha", "Beta", 0), "the base seed must vary the seed"); | |
| assert.notEqual(base, duelSeed(1, "ferros", "medium", "Alpha", "Gamma", 0), "the actual pair must vary the seed"); | |
| }); | |
| /* ---------- duelSeed's seedKey escape hatch (docs/ai-evolution-design.md §8.1) ---------- */ | |
| test("omitting seedKey leaves duelSeed byte-for-byte the derivation it has always been", () => { | |
| // The whole point of the parameter is that it is invisible unless asked for: every existing | |
| // caller (runDuel without an evolutionary opts, every recorded competition row, every saved | |
| // --json duel result) must keep drawing the identical maps. | |
| for (const [world, diff, rep] of [["ferros", "medium", 0], ["korrath", "hard", 3], ["vesper", "easy", 1]]) { | |
| assert.equal(duelSeed(1, world, diff, "Alpha", "Beta", rep), | |
| duelSeed(1, world, diff, "Alpha", "Beta", rep, undefined), | |
| "an explicit undefined seedKey must be identical to omitting it"); | |
| } | |
| }); | |
| test("seedKey replaces the NAMES in the hash, so differently-named pairs share one map set", () => { | |
| // This is the property an evolutionary run needs: generated names (g3i7 vs g2i4) would otherwise | |
| // hash to their own maps every generation, and "the child beat its parent's number" would be | |
| // partly a statement about map luck rather than about the genome. | |
| const a = duelSeed(1, "ferros", "medium", "g3i7", "g2i4", 0, "evolve"); | |
| const b = duelSeed(1, "ferros", "medium", "totally", "different", 0, "evolve"); | |
| assert.equal(a, b, "with a seedKey pinned, the candidate names must not reach the map draw"); | |
| assert.notEqual(a, duelSeed(1, "ferros", "medium", "g3i7", "g2i4", 0), | |
| "and it must actually differ from the unpinned derivation, or it is doing nothing"); | |
| // Everything else still varies exactly as before — the key replaces the names, nothing else. | |
| assert.notEqual(a, duelSeed(1, "korrath", "medium", "g3i7", "g2i4", 0, "evolve")); | |
| assert.notEqual(a, duelSeed(1, "ferros", "hard", "g3i7", "g2i4", 0, "evolve")); | |
| assert.notEqual(a, duelSeed(1, "ferros", "medium", "g3i7", "g2i4", 1, "evolve")); | |
| assert.notEqual(a, duelSeed(2, "ferros", "medium", "g3i7", "g2i4", 0, "evolve")); | |
| assert.notEqual(a, duelSeed(1, "ferros", "medium", "g3i7", "g2i4", 0, "evolve2")); | |
| }); | |
| /* ---------- runDuelMatch (formerly ailab.js's own private duelRun) ---------- */ | |
| const dials = pinnedDuelDials("medium"); | |
| test("runDuelMatch returns exactly the row shape every ailab.js consumer relies on -- no more, no fewer fields", () => { | |
| const row = runDuelMatch({ | |
| world: "ferros", seed: duelSeed(7, "ferros", "medium", "A", "B", 0), dials, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "aggressive", minutes: 5, | |
| }); | |
| const expectedFields = [ | |
| "world", "seed", "difficulty", "swapAsym", "aName", "aStrategy", "bName", "bStrategy", | |
| "aDifficulty", "bDifficulty", "aApm", "bApm", "aMicro", "bMicro", | |
| "winner", "winReason", "time", "aScore", "bScore", "margin", | |
| ]; | |
| assert.deepEqual(Object.keys(row).sort(), [...expectedFields].sort(), | |
| "runDuelMatch's row shape must not change AT ALL -- every existing ailab.js consumer depends on this exact set of fields"); | |
| }); | |
| test("runDuelMatch is deterministic — same inputs, byte-identical row", () => { | |
| const cfg = { | |
| world: "ferros", seed: duelSeed(7, "ferros", "medium", "A", "B", 0), dials, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "aggressive", minutes: 5, | |
| }; | |
| assert.equal(JSON.stringify(runDuelMatch(cfg)), JSON.stringify(runDuelMatch(cfg)), | |
| "two identical calls diverged: something reads a clock or an unseeded pick"); | |
| }); | |
| test("runDuelMatch pins the SAME dials object's apm/micro/difficulty into both sides, read back off the real controllers", () => { | |
| for (const difficulty of ["easy", "hard"]) { | |
| const d = pinnedDuelDials(difficulty); | |
| const dial = DIFFICULTY_OPTIONS.find(o => o.mult === difficulty); | |
| const row = runDuelMatch({ | |
| world: "ferros", seed: duelSeed(3, "ferros", difficulty, "A", "B", 0), dials: d, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "economic", minutes: 5, | |
| }); | |
| assert.equal(row.difficulty, difficulty); | |
| assert.equal(row.aDifficulty, difficulty); | |
| assert.equal(row.bDifficulty, difficulty); | |
| assert.equal(row.aApm, dial.aiApm, "candidate A's own controller must carry this difficulty's aiApm"); | |
| assert.equal(row.bApm, dial.aiApm, "candidate B's own controller must carry the SAME aiApm as A, not its own"); | |
| assert.equal(row.aMicro, !!dial.aiMicro); | |
| assert.equal(row.bMicro, !!dial.aiMicro); | |
| } | |
| }); | |
| test("runDuelMatch reports swapAsym back exactly as given", () => { | |
| const cfg = { | |
| world: "ferros", seed: duelSeed(7, "ferros", "medium", "A", "B", 0), dials, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "aggressive", minutes: 5, | |
| }; | |
| assert.equal(runDuelMatch({ ...cfg, swapAsym: false }).swapAsym, false); | |
| assert.equal(runDuelMatch({ ...cfg, swapAsym: true }).swapAsym, true); | |
| assert.equal(runDuelMatch(cfg).swapAsym, false, "swapAsym must default falsy when omitted, coerced to a real boolean"); | |
| }); | |
| test("runDuelMatch actually resolves a fight: a strong candidate beats a defenceless one", () => { | |
| // neverInitiates + a standing-army cap of ZERO is absolute defencelessness in skirmish (no | |
| // desperation timeout) -- the same fixture shape test/ailab.test.js's own duel tests use, here | |
| // exercised directly against the primitive with a single match rather than a whole worlds x | |
| // seeds matrix (that exhaustive coverage already lives in test/ailab.test.js via runDuel). | |
| STRATEGIES.labDuelCoreCrippled = { name: "labDuelCoreCrippled", desc: "test", neverInitiates: true, standingArmyCap: 0 }; | |
| const row = runDuelMatch({ | |
| world: "korrath", seed: duelSeed(7, "korrath", "medium", "normal", "crippled", 0), dials, | |
| aName: "normal", aStrategy: "default", bName: "crippled", bStrategy: "labDuelCoreCrippled", minutes: 20, | |
| }); | |
| assert.equal(row.winner, "a", `the normal candidate must win (got winner=${row.winner}, reason=${row.winReason})`); | |
| assert.equal(row.winReason, "elimination", "a defenceless base should lose to a genuine assault before the clock"); | |
| assert.ok(row.margin > 0, "the winning side's score margin must be positive"); | |
| }); | |
| /* ---------- D3 (docs/competitions-and-elo.md): aArchetype/bArchetype -- the per-entrant archetype | |
| override, threaded through runDuelMatch's own config into createSelfPlayState's two controllers. | |
| The row shape itself must stay UNCHANGED (archetype is an input dial here, never a reported | |
| output field -- see the exact-shape test above), so this proves the override reaches the sim | |
| some other way: two otherwise-identical runs that disagree only on archetype must diverge. ---------- */ | |
| test("runDuelMatch's aArchetype/bArchetype reach the simulated match without changing the row's own field set", () => { | |
| const cfg = { | |
| world: "ferros", seed: duelSeed(9, "ferros", "medium", "A", "B", 0), dials, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "default", minutes: 8, | |
| }; | |
| const baseline = runDuelMatch(cfg); | |
| const withArchetypes = runDuelMatch({ ...cfg, aArchetype: "rusher", bArchetype: "technologist" }); | |
| assert.deepEqual(Object.keys(withArchetypes).sort(), Object.keys(baseline).sort(), | |
| "supplying an archetype must not add or remove ANY field from the row -- it's an input dial, not an output"); | |
| assert.notEqual(JSON.stringify(baseline), JSON.stringify(withArchetypes), | |
| "two otherwise-identical matches that disagree only on archetype must actually simulate differently -- " + | |
| "proof the override genuinely reaches the created states, not just accepted and ignored"); | |
| }); | |
| test("runDuelMatch treats a missing/null aArchetype/bArchetype as byte-identical to omitting the option entirely", () => { | |
| const cfg = { | |
| world: "ferros", seed: duelSeed(9, "ferros", "medium", "A", "B", 0), dials, | |
| aName: "A", aStrategy: "default", bName: "B", bStrategy: "default", minutes: 8, | |
| }; | |
| const omitted = runDuelMatch(cfg); | |
| const explicitNull = runDuelMatch({ ...cfg, aArchetype: null, bArchetype: undefined }); | |
| assert.equal(JSON.stringify(omitted), JSON.stringify(explicitNull)); | |
| }); | |
| /* ---------- browser importability (docs/competitions-and-elo.md Phase 1: "it will be imported by | |
| a Worker next stage") -- same idiom test/ai-selfplay.test.js already uses for tools/selfplay.js, | |
| pointed at this file instead. ---------- */ | |
| test("tools/duelCore.js has no bare `document` or `window` reference anywhere in its source", () => { | |
| const src = readFileSync(new URL("../tools/duelCore.js", import.meta.url), "utf8"); | |
| const FORBIDDEN = /\bdocument\b|\bwindow\b/; | |
| const offenders = []; | |
| src.split("\n").forEach((line, i) => { | |
| if (FORBIDDEN.test(line)) offenders.push(`${i + 1}: ${line.trim()}`); | |
| }); | |
| assert.deepEqual(offenders, [], | |
| "tools/duelCore.js must have zero `document`/`window` references so a browser Worker can import it cleanly:\n" | |
| + offenders.join("\n")); | |
| }); | |