435 lines
24 KiB
JavaScript
435 lines
24 KiB
JavaScript
/**
|
||
* FACTIONS test (dev tool, run with Node — no browser needed):
|
||
*
|
||
* node dev/factions.test.mjs
|
||
*
|
||
* The faction worldgen layer (data/factions.json + data/gates.json →
|
||
* bridges; js/galaxy/Galaxy.js → _assignFactions; js/galaxy/JumpNetwork.js
|
||
* → bridge pass; js/galaxy/SystemGenerator.js → capital worlds + owners) —
|
||
* see docs/PROJECT_NOTES.md, "FACTIONS". Asserts:
|
||
* - the CONFIG: four factions (neutral/apex/mindweave/zenith), each with
|
||
* a label + hex color; bridges enabled with perPair/dMin/dMax;
|
||
* - the BRANCHES: g.factions.branches = the top-level roots of the jump
|
||
* tree (home's gate neighbors), and branchFaction maps EVERY branch to
|
||
* one of the three player factions (a seeded order);
|
||
* - the NEUTRAL CAPITAL: a direct gate neighbor of home, its system stays
|
||
* neutral (faction null) and hosts the neutral capital world
|
||
* (class capitalNeutral, frame 18, the 'capital' settlement,
|
||
* owner-less); g.neutralCapitalTarget() names that system + its
|
||
* OUTERMOST planet (the capital world) as the 'Leaving the Nest'
|
||
* last-brief's auto destination (js/scenes/GameScene.js → _commEnded);
|
||
* - the FACTION CAPITALS: exactly three, one per faction, each in a
|
||
* non-barren system of its branch, each system carrying the capital
|
||
* world (class capital<faction>, frame 19/20/21) + the 'capital'
|
||
* settlement owned by the faction;
|
||
* - the TERRITORY RULE + BALANCE QUOTA: each branch's middle systems
|
||
* (depth 2 … maxDepth − 1) are ELIGIBLE; each branch keeps its
|
||
* min(eligible, quota) closest to the middle band (|d − 0.5|, index
|
||
* tiebreak), quota = the MEDIAN of the eligible sizes — no faction
|
||
* outruns a typical branch (no dominant faction; the overflow stays
|
||
* neutral wild space, and a small branch keeps everything it has);
|
||
* the ring right outside home (depth 1) + the branch tips (maxDepth)
|
||
* stay neutral — except a faction capital demoted onto a branch root
|
||
* (only when the branch has no territory at all);
|
||
* - ARID: every arid planet is ALWAYS habitable (no roll) and hosts a
|
||
* COLONY (data/settlements.json → settledKindByClass); arid worlds
|
||
* show up in the roster (rebalanced planetClasses);
|
||
* - the BRIDGES: cross-branch (the two endpoints sit in DIFFERENT
|
||
* branches), local (each endpoint in the other's neighbor pool),
|
||
* within the gate budget (≤ maxGates per system), on non-barren
|
||
* systems, mid-band (dMin..dMax) when the branch pair affords it;
|
||
* the snapshot edges carry `bridge: true` for exactly those lanes;
|
||
* - the MAP SNAPSHOT: every system carries faction/capital (null-safe);
|
||
* - DETERMINISM: same seed ⇒ identical factions, capitals, territories,
|
||
* bridges, owners; different seed ⇒ different assignment (spot check).
|
||
*/
|
||
|
||
process.env.NODE_ENV = 'dev';
|
||
|
||
import { pathToFileURL } from 'node:url';
|
||
import { fileURLToPath } from 'node:url';
|
||
import { dirname, join } from 'node:path';
|
||
|
||
const __dirname = dirname(fileURLToPath(import.meta.url));
|
||
|
||
const { config } = await import(pathToFileURL(join(__dirname, '../js/config/Config.js')).href);
|
||
const fs = await import('node:fs');
|
||
const dataDir = join(__dirname, '../data');
|
||
const configData = {};
|
||
for (const f of fs.readdirSync(dataDir)) {
|
||
if (!f.endsWith('.json') || f === 'manifest.json') continue;
|
||
configData[f.replace(/\.json$/i, '')] = JSON.parse(fs.readFileSync(join(dataDir, f), 'utf8'));
|
||
}
|
||
config.init(configData);
|
||
|
||
const { Galaxy } = await import(pathToFileURL(join(__dirname, '../js/galaxy/Galaxy.js')).href);
|
||
const { buildGalaxySnapshot, edgeKey } = await import(pathToFileURL(join(__dirname, '../js/galaxy/GalaxyChart.js')).href);
|
||
|
||
let failures = 0;
|
||
const check = (label, cond, extra = '') => {
|
||
console.log(`${cond ? '✔' : '✘ FAIL'} ${label}${cond ? '' : ' — ' + extra}`);
|
||
if (!cond) failures++;
|
||
};
|
||
|
||
const FACS = config.get('factions.factions', {});
|
||
const FIDS = Object.keys(FACS).filter((k) => k !== 'neutral');
|
||
const BRC = config.get('gates.bridges', {});
|
||
const MAX_GATES = config.get('gates.maxGates', 3);
|
||
const POOL = Math.max(1, config.get('gates.neighborPool', 8));
|
||
|
||
// ----------------------------------------------------------------------
|
||
// 0. The config
|
||
// ----------------------------------------------------------------------
|
||
{
|
||
check('factions.json: neutral + apex + mindweave + zenith, each labeled + colored',
|
||
['neutral', 'apex', 'mindweave', 'zenith'].every((k) => typeof FACS[k]?.label === 'string' && /^#[0-9a-f]{6}$/i.test(FACS[k]?.color ?? '')));
|
||
check('bridges config: enabled, perPair ≥ 1, 0 < dMin < dMax < 1',
|
||
BRC.enabled === true && Number(BRC.perPair) >= 1 && Number(BRC.dMin) > 0 && Number(BRC.dMax) < 1 && Number(BRC.dMin) < Number(BRC.dMax));
|
||
check('capital planet classes + frames 18..21 (planets.json → capitals)',
|
||
FIDS.concat('neutral').every((fid) => {
|
||
const cls = `capital${fid.charAt(0).toUpperCase()}${fid.slice(1)}`;
|
||
return Array.isArray(config.get(`planets.frames.${cls}`)) && config.get(`planets.capitals.frames.${fid}`, -1) >= 18;
|
||
}));
|
||
check("the 'capital' settlement kind + arid→colony mapping exist",
|
||
typeof config.get('settlements.kinds.capital') === 'object' && config.get('settlements.settledKindByClass.arid') === 'colony' && FIDS.every((f) => config.get(`settlements.settledKindByClass.capital${f.charAt(0).toUpperCase()}${f.slice(1)}`) === 'capital'));
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// Shared walks: tree depth (home = 0) + per-system branch root.
|
||
// ----------------------------------------------------------------------
|
||
const SEED = 'factions-test-seed';
|
||
const g = Galaxy.create(SEED);
|
||
const HOME = g.currentSystemId;
|
||
const recOf = new Map(g.records.map((r) => [r.id, r]));
|
||
// The BRANCH STRUCTURE comes from the jump network's own spanning tree
|
||
// (js/galaxy/JumpNetwork.js exposes branches/branchOf/depth — the exact
|
||
// tree the bridge pass used; a BFS over the final gate list — tree +
|
||
// bridges — can re-parent systems across branches, which is NOT the
|
||
// branch structure the faction pass assigns).
|
||
const branchOf = g.jumpNetwork.branchOf; // Map id → branch root id
|
||
const depth = g.jumpNetwork.depth; // Map id → tree depth (home = 0)
|
||
const treeBranches = [...new Set([...branchOf.values()])];
|
||
const isBarren = (id) => {
|
||
if (id === HOME) return false;
|
||
const c = g.ensureContent(id);
|
||
const spaceCount = (c.settlements ?? []).filter((s) => s.anchor?.type === 'space').length;
|
||
return c.planets.length === 0 && spaceCount === 0;
|
||
};
|
||
|
||
// ----------------------------------------------------------------------
|
||
// 1. Branches, neutral capital, faction capitals, territory, owners
|
||
// ----------------------------------------------------------------------
|
||
{
|
||
check('factions present on the galaxy (neutral capital + 3 capitals + branches + mapping)',
|
||
!!g.factions && typeof g.factions.neutralCapital === 'string'
|
||
&& (Object.keys(g.factions.capitals ?? {}).length === 3)
|
||
&& Array.isArray(g.factions.branches) && g.factions.branches.length >= 2
|
||
&& typeof g.factions.branchFaction === 'object');
|
||
|
||
check('branches = the tree\u2019s top-level roots (home\u2019s gate neighbors)',
|
||
JSON.stringify([...g.factions.branches].sort()) === JSON.stringify([...new Set(treeBranches)].sort())
|
||
&& JSON.stringify([...g.factions.branches].sort()) === JSON.stringify(g.jumpNetwork.branches),
|
||
`${g.factions.branches.length} vs ${new Set(treeBranches).size}`);
|
||
|
||
check('branchFaction: every branch mapped to one of the 3 player factions',
|
||
g.factions.branches.every((b) => FIDS.includes(g.factions.branchFaction[b])));
|
||
|
||
// The NEUTRAL CAPITAL: a direct gate neighbor of home; its system stays
|
||
// neutral (faction null) + hosts the neutral capital world.
|
||
const nc = g.factions.neutralCapital;
|
||
const ncRec = recOf.get(nc);
|
||
check('neutral capital: a direct gate neighbor of home', ncRec && g.jumpGatesFor(HOME).some((t) => t.id === nc), nc);
|
||
check('neutral capital: its system stays neutral (faction null) but is designated',
|
||
!!ncRec && ncRec.faction === null && ncRec.capital === 'neutral',
|
||
ncRec ? `${ncRec.faction}/${ncRec.capital}` : 'missing record');
|
||
const ncContent = g.ensureContent(nc);
|
||
const ncPlanet = ncContent.planets.find((p) => p.capital);
|
||
check('neutral capital: hosts the capital world (class capitalNeutral, frame 18, habitable)',
|
||
!!ncPlanet && ncPlanet.class === 'capitalNeutral' && ncPlanet.frame === 18 && ncPlanet.habitable === true,
|
||
ncPlanet ? `${ncPlanet.class}/f${ncPlanet.frame}` : 'no capital planet');
|
||
const ncSettle = ncContent.settlements.find((s) => s.kind === 'capital');
|
||
check('neutral capital: the capital world hosts an owner-less capital settlement',
|
||
!!ncSettle && ncSettle.owner === null && ncSettle.anchor?.ordinal === ncPlanet?.ordinal,
|
||
ncSettle ? `${ncSettle.kind} owner=${ncSettle.owner}` : 'no capital settlement');
|
||
|
||
// The destination target (the 'Leaving the Nest' last brief — Trestle
|
||
// "sends the coordinates"; js/scenes/GameScene.js → _commEnded hands
|
||
// this to setDestination on the acknowledgment). The object id is the
|
||
// map's discoveryId vocabulary (the planet's NAME — what MapWindow's
|
||
// SET DESTINATION passes + the arrival/compass/plate lookups read).
|
||
const ncTarget = g.neutralCapitalTarget();
|
||
const ncOuter = ncContent.planets[ncContent.planets.length - 1];
|
||
check('neutral capital target: system = the designated capital + the capital world is the OUTERMOST planet (object id = its name)',
|
||
ncTarget?.systemId === nc
|
||
&& ncTarget?.objectId === ncOuter?.name
|
||
&& ncOuter?.capital === true && ncOuter?.class === 'capitalNeutral',
|
||
ncTarget ? `${ncTarget.systemId} / ${ncTarget.objectId}` : 'null target');
|
||
|
||
// The FACTION CAPITALS: one per faction, non-barren, capital world of
|
||
// the faction's class + frame, settlement owned by the faction.
|
||
const capFrames = { apex: 19, mindweave: 20, zenith: 21 };
|
||
const caps = Object.entries(g.factions.capitals ?? {});
|
||
check('exactly 3 faction capitals, one per faction, distinct systems',
|
||
caps.length === 3 && new Set(caps.map(([, id]) => id)).size === 3
|
||
&& caps.every(([fid, id]) => FIDS.includes(fid) && recOf.has(id) && recOf.get(id).faction === fid && recOf.get(id).capital === fid));
|
||
let capWorlds = true;
|
||
let capWhy = '';
|
||
for (const [fid, id] of caps) {
|
||
const cls = `capital${fid.charAt(0).toUpperCase()}${fid.slice(1)}`;
|
||
const c = g.ensureContent(id);
|
||
const p = c.planets.find((pl) => pl.capital);
|
||
const s = c.settlements.find((st) => st.kind === 'capital');
|
||
if (!p || p.class !== cls || p.frame !== capFrames[fid] || p.habitable !== true) { capWorlds = false; capWhy = `${id}: planet ${p ? `${p.class}/f${p.frame}` : 'none'}`; break; }
|
||
if (!s || s.owner !== fid) { capWorlds = false; capWhy = `${id}: settlement owner ${s?.owner ?? 'none'}`; break; }
|
||
}
|
||
check('faction capitals: capital world (class + frame + habitable) + faction-owned settlement', capWorlds, capWhy);
|
||
|
||
// TERRITORY + BALANCE QUOTA: the branch's middle systems (depth 2 …
|
||
// maxDepth − 1) are ELIGIBLE; each branch keeps its min(eligible, quota)
|
||
// closest to the middle band (|d − 0.5|, index tiebreak) — quota = the
|
||
// MEDIAN of the eligible sizes, so no faction can outsize a typical
|
||
// branch (the overflow stays neutral wild space); a small branch keeps
|
||
// everything it has (except a faction capital demoted onto a branch
|
||
// root — only when the branch has no territory at all).
|
||
const branchMax = new Map(g.factions.branches.map((b) => [b, 0]));
|
||
const eligibleOf = new Map(g.factions.branches.map((b) => [b, []]));
|
||
for (const [id, d] of depth) {
|
||
if (id === HOME || !branchOf.has(id)) continue;
|
||
const b = branchOf.get(id);
|
||
branchMax.set(b, Math.max(branchMax.get(b), d));
|
||
}
|
||
for (const r of g.records) {
|
||
if (r.id === HOME || !branchOf.has(r.id)) continue;
|
||
const b = branchOf.get(r.id);
|
||
const d = depth.get(r.id);
|
||
if (d >= 2 && d <= branchMax.get(b) - 1) eligibleOf.get(b).push(r.id);
|
||
}
|
||
const sizes = g.factions.branches.map((b) => eligibleOf.get(b).length).sort((x, y) => x - y);
|
||
const quota = sizes[Math.floor((sizes.length - 1) / 2)];
|
||
const idx = new Map(g.records.map((r, i) => [r.id, i]));
|
||
const mid = (id) => Math.abs((g.byId.get(id)?.d ?? 0.5) - 0.5);
|
||
const keepOf = new Map(g.factions.branches.map((b) => {
|
||
const elig = eligibleOf.get(b);
|
||
return [b, new Set(elig.slice().sort((a, c) => mid(a) - mid(c) || idx.get(a) - idx.get(c)).slice(0, Math.min(elig.length, quota)))];
|
||
}));
|
||
|
||
check('balance quota: the median of the branches’ eligible sizes', g.factions.quota === quota, `${g.factions.quota} vs ${quota} (sizes ${sizes.join(',')})`);
|
||
|
||
let terrOk = true;
|
||
let terrWhy = '';
|
||
for (const r of g.records) {
|
||
if (r.id === HOME || !branchOf.has(r.id)) continue;
|
||
const b = branchOf.get(r.id);
|
||
const fid = g.factions.branchFaction[b];
|
||
const expectFaction = keepOf.get(b).has(r.id) ? fid : null;
|
||
const got = r.faction === fid ? fid : null;
|
||
const demoted = g.factions.capitals[fid] === r.id && expectFaction === null;
|
||
if (got !== expectFaction && !(demoted && got === fid)) {
|
||
terrOk = false;
|
||
terrWhy = `${r.id}: keep=${keepOf.get(b).has(r.id)} expect=${expectFaction} got=${got}`;
|
||
break;
|
||
}
|
||
}
|
||
check('territory rule: the branch’s kept (quota-capped) middle systems = its faction; the rest neutral', terrOk, terrWhy);
|
||
|
||
// NO DOMINANT FACTION: every territory is exactly its branch's
|
||
// min(eligible, quota) systems — the big branch is trimmed to the
|
||
// median, the small branch keeps everything; and the kept set is the
|
||
// middle-band-nearest one (the map's territory-region fill will read
|
||
// factions.territories).
|
||
let terrSizeOk = true;
|
||
let terrSizeWhy = '';
|
||
for (const b of g.factions.branches) {
|
||
const terr = g.factions.territories?.[b] ?? [];
|
||
const want = Math.min(eligibleOf.get(b).length, quota);
|
||
if (terr.length !== want) { terrSizeOk = false; terrSizeWhy = `${b}: ${terr.length} systems, want ${want}`; break; }
|
||
for (const id of terr) {
|
||
if (!keepOf.get(b).has(id)) { terrSizeOk = false; terrSizeWhy = `${b}: ${id} is not among its ${want} middle-band-nearest eligible systems`; break; }
|
||
}
|
||
if (!terrSizeOk) break;
|
||
}
|
||
check('no dominant faction: every territory is its branch’s min(eligible, quota) middle-band systems', terrSizeOk, terrSizeWhy);
|
||
const terrSizes = g.factions.branches.map((b) => g.factions.territories[b].length);
|
||
check('faction sizes near-equal: max territory ≤ quota (no faction outruns a typical branch)', Math.max(...terrSizes) <= quota, `sizes ${terrSizes.join('/')} quota ${quota}`);
|
||
|
||
// OWNERS: every settlement in a faction-controlled system is owned by
|
||
// that faction (neutral systems: owner null) — the reputation seam is
|
||
// live, not a reserved null anymore.
|
||
let ownOk = true;
|
||
let ownWhy = '';
|
||
for (const r of g.records) {
|
||
const c = g.ensureContent(r.id);
|
||
for (const s of c.settlements) {
|
||
if (s.owner !== r.faction) { ownOk = false; ownWhy = `${r.id}: settlement ${s.kind} owner=${s.owner} system faction=${r.faction}`; break; }
|
||
}
|
||
if (!ownOk) break;
|
||
}
|
||
check('settlement owners: faction systems own their settlements; neutral space does not', ownOk, ownWhy);
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// 2. Arid — the common habitable class (frames 15..17)
|
||
// ----------------------------------------------------------------------
|
||
{
|
||
const ARID = config.get('planets.frames.arid');
|
||
check('arid frames are 15..17 (planets.json)', JSON.stringify(ARID) === '[15,16,17]', JSON.stringify(ARID));
|
||
let seenArid = 0, aridHabit = true, aridColony = true;
|
||
let whyHabit = '', whyColony = '';
|
||
for (const r of g.records) {
|
||
const c = g.ensureContent(r.id);
|
||
for (const p of c.planets) {
|
||
if (p.class !== 'arid') continue;
|
||
seenArid++;
|
||
if (p.habitable !== true) { aridHabit = false; whyHabit = `${r.id}/${p.name}: arid not habitable`; }
|
||
const s = c.settlements.find((st) => st.anchor?.type === 'planet' && st.anchor?.ordinal === p.ordinal && st.kind === 'colony');
|
||
if (!s) { aridColony = false; whyColony = `${r.id}/${p.name}: no colony on arid`; }
|
||
}
|
||
}
|
||
check(`arid worlds appear in the roster (${seenArid} found)`, seenArid > 0, 'none found');
|
||
check('every arid world is habitable (the always-habitable class)', aridHabit, whyHabit);
|
||
check('every arid world hosts a colony', aridColony, whyColony);
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// 3. Bridges — the inter-branch middle-belt links
|
||
// ----------------------------------------------------------------------
|
||
{
|
||
const bridges = g.jumpNetwork?.bridges ?? [];
|
||
const maxBridges = BRC.enabled === false ? 0 : BRC.perPair * (g.factions.branches.length * (g.factions.branches.length - 1) / 2);
|
||
check(`bridges placed: ${bridges.length} (> 0, ≤ ${maxBridges})`,
|
||
bridges.length > 0 && bridges.length <= maxBridges,
|
||
`${bridges.length}`);
|
||
|
||
let span = true, local = true, budget = true, barren = true;
|
||
let spanWhy = '', localWhy = '', budgetWhy = '', barrenWhy = '';
|
||
for (const [a, b] of bridges) {
|
||
const ba = branchOf.get(a), bb = branchOf.get(b);
|
||
if (a === b) { span = false; spanWhy = `${a} self-loop`; continue; }
|
||
if (ba === undefined || bb === undefined || ba === bb) { span = false; spanWhy = `${a}(branch ${ba ?? '?'})↔${b}(branch ${bb ?? '?'})`; continue; }
|
||
const inPool = g.neighborsOf(a, POOL).some((x) => x.id === b) || g.neighborsOf(b, POOL).some((x) => x.id === a);
|
||
if (!inPool) { local = false; localWhy = `${a}↔${b} outside the ${POOL}-nearest pool`; }
|
||
if (g.jumpGatesFor(a).length > MAX_GATES || g.jumpGatesFor(b).length > MAX_GATES) { budget = false; budgetWhy = `${a}(${g.jumpGatesFor(a).length})/${b}(${g.jumpGatesFor(b).length}) > ${MAX_GATES}`; }
|
||
if (isBarren(a) || isBarren(b)) { barren = false; barrenWhy = `${a} or ${b} is barren`; }
|
||
}
|
||
check('every bridge spans two different branches (on the TREE branch map)', span, spanWhy);
|
||
check('every bridge is local (endpoints in each other\u2019s neighbor pool)', local, localWhy);
|
||
check('bridges respect the gate budget (≤ maxGates per system)', budget, budgetWhy);
|
||
check('bridges never touch barren systems', barren, barrenWhy);
|
||
|
||
// THE PREFERENCE, verified by re-simulating the bridge pass (it is a
|
||
// pure function of the roster + pools + budget + config): a faithful
|
||
// replay must reproduce the EXACT placed bridges, in order — which
|
||
// subsumes the middle-belt preference (band pairs sort first), the
|
||
// distinct-endpoint preference (pass 0), and the per-pair count.
|
||
const k = (a, b) => (a < b ? a : b) + '\u0000' + (a < b ? b : a);
|
||
const bridgeKeys = new Set(bridges.map(([a, b]) => k(a, b)));
|
||
const n = g.records.length;
|
||
const idx = new Map(g.records.map((r, i) => [r.id, i]));
|
||
const root = idx.get(HOME);
|
||
const out = g.records.map((r) => g.neighborsOf(r.id, POOL).map((x) => idx.get(x.id)));
|
||
const rev = Array.from({ length: n }, () => []);
|
||
for (let i = 0; i < n; i++) for (const j of out[i]) rev[j].push(i);
|
||
const nbr = g.records.map((_, i) => {
|
||
const seen = new Set(out[i]);
|
||
const arr = out[i].slice();
|
||
for (const j of rev[i]) if (!seen.has(j)) { seen.add(j); arr.push(j); }
|
||
return arr;
|
||
});
|
||
// Starting degrees: the tree degree (the gate list minus the bridge
|
||
// targets it carries — shortcuts are OFF in the config, so the gate
|
||
// list is tree edges + bridge gates). jumpGatesFor returns RECORD
|
||
// objects — map to ids first.
|
||
const deg = g.records.map((r) => g.jumpGatesFor(r.id).map((t) => t.id).filter((t) => !bridgeKeys.has(k(r.id, t))).length);
|
||
const dMin = Number(BRC.dMin), dMax = Number(BRC.dMax);
|
||
const dOf = (i) => Number(g.records[i].d);
|
||
const inBand = (i) => dOf(i) >= dMin && dOf(i) <= dMax;
|
||
const bOf = (i) => {
|
||
const b = branchOf.get(g.records[i].id); // branch root id (string)
|
||
return b !== undefined ? idx.get(b) : -1;
|
||
};
|
||
const dist2 = (a, b) => {
|
||
const dx = g.records[a].x - g.records[b].x;
|
||
const dy = g.records[a].y - g.records[b].y;
|
||
return dx * dx + dy * dy;
|
||
};
|
||
const simulated = [];
|
||
const branchesSorted = g.jumpNetwork.branches.map((id) => idx.get(id)).sort((a, b) => a - b);
|
||
for (let bi = 0; bi < branchesSorted.length; bi++) {
|
||
for (let bj = bi + 1; bj < branchesSorted.length; bj++) {
|
||
const A = branchesSorted[bi], B = branchesSorted[bj];
|
||
const cands = [];
|
||
for (let u = 0; u < n; u++) {
|
||
if (bOf(u) !== A || isBarren(g.records[u].id) || u === root) continue;
|
||
for (const v of nbr[u]) {
|
||
if (bOf(v) !== B || isBarren(g.records[v].id) || v === root) continue;
|
||
cands.push({ u, v, band: inBand(u) && inBand(v), d: dist2(u, v) });
|
||
}
|
||
}
|
||
cands.sort((p, q) =>
|
||
(p.band === q.band ? 0 : p.band ? -1 : 1) ||
|
||
p.d - q.d || p.u - q.u || p.v - q.v);
|
||
const usedEnds = new Set();
|
||
let added = 0;
|
||
for (let pass = 0; pass < 2 && added < BRC.perPair; pass++) {
|
||
for (const c of cands) {
|
||
if (added >= BRC.perPair || c.added) continue;
|
||
if (pass === 0 && (usedEnds.has(c.u) || usedEnds.has(c.v))) continue;
|
||
if (deg[c.u] >= MAX_GATES || deg[c.v] >= MAX_GATES) continue;
|
||
c.added = true;
|
||
deg[c.u]++;
|
||
deg[c.v]++;
|
||
usedEnds.add(c.u);
|
||
usedEnds.add(c.v);
|
||
simulated.push([g.records[c.u].id, g.records[c.v].id]);
|
||
added++;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const simOk = JSON.stringify(simulated) === JSON.stringify(bridges);
|
||
check('bridge pass replay: a faithful re-simulation reproduces the exact placed bridges (in order — locality, budget, band + distinct-endpoint preference)',
|
||
simOk,
|
||
simOk ? '' : `got ${JSON.stringify(bridges)} vs simulated ${JSON.stringify(simulated)}`);
|
||
|
||
// The snapshot: edges.bridge flags exactly the bridge lanes (and the
|
||
// systems carry faction/capital).
|
||
const snap = buildGalaxySnapshot({ galaxy: g });
|
||
const snapBridge = new Set();
|
||
for (const e of snap.edges) if (e.bridge) snapBridge.add(e.key);
|
||
const wantBridge = new Set(bridges.map(([a, b]) => edgeKey(a, b)));
|
||
check('snapshot edges carry bridge:true for exactly the placed bridges',
|
||
snapBridge.size === wantBridge.size && [...wantBridge].every((x) => snapBridge.has(x)),
|
||
`${snapBridge.size} vs ${wantBridge.size}`);
|
||
const sysOk = snap.systems.every((s) => s.faction === null || FIDS.includes(s.faction))
|
||
&& snap.systems.every((s) => s.capital === null || ['neutral', ...FIDS].includes(s.capital));
|
||
check('snapshot systems carry faction (null | faction id) + capital (null | designation)', sysOk);
|
||
}
|
||
|
||
// ----------------------------------------------------------------------
|
||
// 4. Determinism — same seed ⇒ identical; different seed ⇒ different
|
||
// ----------------------------------------------------------------------
|
||
{
|
||
const g2 = Galaxy.create(SEED);
|
||
const sameF = JSON.stringify(g.factions) === JSON.stringify(g2.factions);
|
||
let sameTerr = true;
|
||
for (let i = 0; i < g.records.length && sameTerr; i++) {
|
||
if (g.records[i].faction !== g2.records[i].faction || g.records[i].capital !== g2.records[i].capital) sameTerr = false;
|
||
}
|
||
let sameBridges = JSON.stringify(g.jumpNetwork?.bridges) === JSON.stringify(g2.jumpNetwork?.bridges);
|
||
check('same seed ⇒ identical factions (capitals + branches + mapping)', sameF);
|
||
check('same seed ⇒ identical per-system faction/capital designations', sameTerr);
|
||
check('same seed ⇒ identical bridges', sameBridges);
|
||
|
||
const g3 = Galaxy.create('factions-test-OTHER');
|
||
let diff = false;
|
||
for (let i = 0; i < 60 && !diff; i++) {
|
||
const a = g.records[i], b = g3.records[i];
|
||
if (a.id !== b.id) continue;
|
||
if (a.faction !== b.faction || a.capital !== b.capital) diff = true;
|
||
}
|
||
check('different seed ⇒ different faction assignment (spot check)', diff);
|
||
}
|
||
|
||
console.log(failures === 0 ? '\nAll faction tests passed ✔' : `\n${failures} test(s) FAILED ✘`);
|
||
process.exit(failures === 0 ? 0 : 1);
|