9.3 自走棋的涌现

涌现度(‰) = floor(1000 × 可达阵容数 / 规则条数) = floor(1000 × 9390 / 16) = 586875

// file: core/test/gd_proto_09_3_emergence.test.ts
// tier: P
// verify: node --test 'core/test/gd_proto_09_3_emergence.test.ts'
//
// 卷三 9.3 自走棋的涌现（P 层）：用「可达阵容数 / 规则条数 × 1000」当**涌现度代理指标**，
// 并把「每一回合都能赢」的阵容数当成退化检测量——它塌缩到 1 就是唯一解（退化解），
// 塌缩到 0 就是无解。数量小到可以全枚举，所以这里全是精确值，不是采样估计。
// 涌现度是**代理指标（proxy）**，只做相对比较，禁绝对化。全整数、无浮点、无 random。

import { test } from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";

import { abComps, abEmergence, abBoardPower, abCopies } from "../genre/autobattler.ts";

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, "..", "..");
const load = (name: string) => JSON.parse(readFileSync(join(ROOT, "config", name), "utf8"));
const EM = load("gd_proto_09_emergence.json");
const CAP = EM.emergence.capacity;
const CAP_LIMIT = EM.emergence.cap;

test("枚举规模可控：9390 个可达阵容，未触及 20 万上限", () => {
  const { all, capHit } = abComps(EM, CAP, CAP_LIMIT);
  assert.equal(all.length, 9390);
  assert.equal(capHit, false);
  // 每个阵容都同时满足「棋子数 ≤ 上阵容量」与「每个单位的份数 ≤ poolPerUnit」。
  for (const comp of all) {
    assert.equal(comp.length <= CAP, true);
    const per: Record<string, number> = {};
    for (const p of comp) per[p.id] = (per[p.id] ?? 0) + abCopies(p.star);
    for (const k of Object.keys(per)) assert.equal(per[k] <= EM.rules.poolPerUnit, true);
  }
});

test("涌现度 = 可达阵容数 / 规则条数 × 1000（代理指标，禁绝对化）", () => {
  const e = abEmergence(EM, CAP, CAP_LIMIT);
  assert.equal(e.ruleCount, 16);
  assert.equal(e.reachablePermille, 586875); // 1000 × 9390 / 16，整数地板除
  assert.equal(Math.floor((1000 * e.comps) / e.ruleCount), 586875);
});

test("末回合能赢的阵容 3885 个，每一回合都能赢的 2963 个（未退化）", () => {
  const e = abEmergence(EM, CAP, CAP_LIMIT);
  assert.equal(e.winFinal, 3885);
  assert.equal(e.winAll, 2963);
  assert.equal(e.winningPermille, 413);
  assert.equal(e.degenerate, false);
  assert.equal(e.finalEnemyPower, 147); // enemyBase 26 + enemyStep 11 × 11
});

test("唯一最大战力阵容：254 战力，只有 1 个阵容达到（末回合敌方 147）", () => {
  const e = abEmergence(EM, CAP, CAP_LIMIT);
  assert.equal(e.bestPower, 254);
  assert.equal(e.bestCount, 1);
  assert.deepEqual(e.bestComp, ["blade_grunt:3", "ward_sentinel:3", "arcane_adept:2",
    "arcane_adept:3", "blade_champion:2", "blade_champion:3"]);
  const copies = [9, 9, 3, 9, 3, 9].reduce((a, b) => a + b, 0);
  assert.equal(copies, 42); // ≤ 48：份数约束真的在起作用
});

test("克制关系是涌现的来源：同一个阵容对三种敌方羁绊给出三个不同战力", () => {
  const comp = [{ id: "blade_grunt", star: 1 }, { id: "ward_sentinel", star: 1 },
    { id: "arcane_adept", star: 1 }];
  const p = EM.rules.enemyTraits.map((t: string) => abBoardPower(EM, comp, t));
  assert.deepEqual(p, [40, 43, 41]);
  assert.equal(new Set(p).size, 3);
});

test("退化扫描：敌方强度扫过 20 时唯一解，21 起无解（如实报告）", () => {
  const sweep: [number, number, number, boolean][] = [];
  for (let st = 11; st <= 34; st += 1) {
    const sp = JSON.parse(JSON.stringify(EM));
    sp.params.enemyStep = st;
    const e = abEmergence(sp, CAP, CAP_LIMIT);
    sweep.push([st, e.winAll, e.winFinal, e.degenerate]);
  }
  console.log("  enemyStep  每回合都能赢  末回合能赢  退化");
  for (const [st, wa, wf, dg] of sweep) {
    console.log(`  ${String(st).padStart(9)} ${String(wa).padStart(11)} ${String(wf).padStart(11)}   ${dg ? "是" : "否"}`);
  }
  const at = (s: number) => sweep.find((x) => x[0] === s) as [number, number, number, boolean];
  assert.deepEqual(at(11), [11, 2963, 3885, false]);
  assert.deepEqual(at(15), [15, 427, 694, false]);
  assert.deepEqual(at(19), [19, 10, 15, false]);
  assert.deepEqual(at(20), [20, 1, 1, true]);  // 退化解：只有一个阵容每回合都赢
  assert.deepEqual(at(21), [21, 0, 0, true]);  // 无解：没有阵容能赢
  assert.deepEqual(at(34), [34, 0, 0, true]);
  // 单调性：敌方越强，「每回合都能赢」的阵容只会更少，不会更多。
  for (let i = 1; i < sweep.length; i += 1) assert.equal(sweep[i][1] <= sweep[i - 1][1], true);
});

test("涌现度不是「越多越好」：它是阵容池宽度对规格复杂度的比，必须与退化检测同读", () => {
  const wide = abEmergence(EM, CAP, CAP_LIMIT);
  const narrow = JSON.parse(JSON.stringify(EM));
  narrow.params.enemyStep = 20;
  const tight = abEmergence(narrow, CAP, CAP_LIMIT);
  assert.equal(wide.comps, tight.comps);            // 阵容池本身没变
  assert.equal(wide.reachablePermille, tight.reachablePermille);
  assert.equal(wide.winAll, 2963);
  assert.equal(tight.winAll, 1);                    // 但可赢的那一层塌缩成 1
  assert.equal(tight.degenerate, true);
});

# snippet: 跑本节 P 层
node --test 'core/test/gd_proto_09_3_emergence.test.ts'

  enemyStep  每回合都能赢  末回合能赢  退化
         11        2963        3885   否
         12        2061        2853   否
         13        1302        1913   否
         14         782        1223   否
         15         427         694   否
         16         232         374   否
         17         107         160   否
         18          38          53   否
         19          10          15   否
         20           1           1   是
         21           0           0   是
         22           0           0   是
         23           0           0   是
         24           0           0   是
         25           0           0   是
         26           0           0   是
         27           0           0   是
         28           0           0   是
         29           0           0   是
         30           0           0   是
         31           0           0   是
         32           0           0   是
         33           0           0   是
         34           0           0   是
✔ 枚举规模可控：9390 个可达阵容，未触及 20 万上限
✔ 涌现度 = 可达阵容数 / 规则条数 × 1000（代理指标，禁绝对化）
✔ 末回合能赢的阵容 3885 个，每一回合都能赢的 2963 个（未退化）
✔ 唯一最大战力阵容：254 战力，只有 1 个阵容达到（末回合敌方 147）
✔ 克制关系是涌现的来源：同一个阵容对三种敌方羁绊给出三个不同战力
✔ 退化扫描：敌方强度扫过 20 时唯一解，21 起无解（如实报告）
✔ 涌现度不是「越多越好」：它是阵容池宽度对规格复杂度的比，必须与退化检测同读
ℹ tests 7
ℹ pass 7
ℹ fail 0