5.3 构筑的相变

// file: core/test/gd_proto_05_phase.test.ts
// tier: P
// verify: node --test 'core/test/gd_proto_05_phase.test.ts'
//
// 5.3 构筑的相变（P 层）：扫一个**构筑参数**——牌组规模。往基线牌库里加 N 张「废牌」
// （cost 1 / damage 0 / block 0），牌组从 12 张膨胀到 32 张，序参量取 128 个种子上的
// 胜率（千分比，proxy）。粗扫步长 4 定位跨越 500‰ 的相邻区间，再二分到 ±1，最后与步长 1
// 的全网格逐点比对，确认扫描器没有跨过换相点。脚本报告格数、run 数、相变带宽与总耗时。
// 全整数、无浮点、无 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 { runSpec } from "../src/ashdeck/combat.ts";
import type { Spec } from "../src/ashdeck/types.ts";

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, "..", "..");
const SPEC: Spec = JSON.parse(readFileSync(join(ROOT, "config", "play_spec.json"), "utf8"));
const POOL = Array.from({ length: 128 }, (_, i) => 301 + i);
const DECK0 = SPEC.cards.reduce((a, c) => a + c.count, 0); // 12
const LO = DECK0, HI = DECK0 + 20, COARSE = 4, CROSS = 500;

/** 构筑 = 往牌库里加 N 张废牌，牌组规模 = 12 + N。 */
function withDuds(deckSize: number): Spec {
  const sp: Spec = JSON.parse(JSON.stringify(SPEC));
  sp.cards = sp.cards.concat([
    { id: "dud", cost: 1, damage: 0, block: 0, count: deckSize - DECK0, rarity: "common" },
  ]);
  return sp;
}

/** 序参量：种子池上的胜率（千分比）。代理指标，只做相对比较。 */
function winPermille(deckSize: number): number {
  const sp = withDuds(deckSize);
  let w = 0;
  for (const sd of POOL) {
    const s: Spec = JSON.parse(JSON.stringify(sp));
    s.seed = sd;
    if (runSpec(s).won) w += 1;
  }
  return Math.floor((1000 * w) / POOL.length);
}

test("相变扫描：粗扫 + 二分定位「构筑被解开」的牌组规模", () => {
  const t0 = process.hrtime.bigint();
  const cache = new Map<number, number>();
  const wp = (d: number): number => {
    if (!cache.has(d)) cache.set(d, winPermille(d));
    return cache.get(d) as number;
  };

  // 粗扫：步长 4
  const coarse: [number, number][] = [];
  for (let d = LO; d <= HI; d += COARSE) coarse.push([d, wp(d)]);
  let bracket: [number, number] | null = null;
  for (let i = 0; i < coarse.length - 1; i += 1) {
    if (coarse[i][1] >= CROSS && coarse[i + 1][1] < CROSS) bracket = [coarse[i][0], coarse[i + 1][0]];
  }
  assert.ok(bracket, "粗扫应找到一个跨越 500‰ 的相邻区间");

  // 二分细化到 ±1
  let a = (bracket as [number, number])[0];
  let b = (bracket as [number, number])[1];
  let rounds = 0;
  while (b - a > 1) {
    const mid = (a + b) >> 1;
    rounds += 1;
    if (wp(mid) >= CROSS) a = mid; else b = mid;
  }
  const critical = b;

  // 全网格（步长 1）作真值
  const full: number[] = [];
  for (let d = LO; d <= HI; d += 1) full.push(wp(d));
  const fullCritical = LO + full.findIndex((v) => v < CROSS);
  const band = full.filter((v) => v >= 100 && v <= 900).length;
  const elapsedMs = Number(process.hrtime.bigint() - t0) / 1e6;

  console.log("=== 5.3 构筑的相变扫描（牌组规模 12 → 32）===");
  console.log("粗扫(步长 4): " + coarse.map(([d, v]) => d + ":" + v).join("  "));
  console.log("跨越 500‰ 的区间: [" + (bracket as [number, number])[0] + ", " +
    (bracket as [number, number])[1] + "]  二分轮数=" + rounds);
  console.log("全网格(步长 1): " + full.join(" "));
  console.log("临界牌组规模=" + critical + "  全网格临界=" + fullCritical +
    "  一致=" + (critical === fullCritical));
  console.log("相变带宽(100‰..900‰)=" + band + "  格数=" + cache.size +
    "  runs=" + cache.size * POOL.length);
  console.log("elapsed=" + elapsedMs.toFixed(1) + " ms");

  assert.equal(coarse.length, 6);
  assert.deepEqual(bracket, [20, 24]);
  assert.equal(rounds, 2);
  assert.equal(critical, 22);
  assert.equal(critical, fullCritical);
  assert.equal(cache.size, 21);
  assert.equal(cache.size * POOL.length, 2688);
  assert.equal(band, 13);
});

=== 5.3 构筑的相变扫描（牌组规模 12 → 32）===
粗扫(步长 4): 12:1000  16:945  20:625  24:281  28:117  32:46
跨越 500‰ 的区间: [20, 24]  二分轮数=2
全网格(步长 1): 1000 1000 1000 992 945 937 875 734 625 609 492 328 281 328 195 164 117 117 109 78 46
临界牌组规模=22  全网格临界=22  一致=true
相变带宽(100‰..900‰)=13  格数=21  runs=2688
elapsed=28.4 ms
✔ 相变扫描：粗扫 + 二分定位「构筑被解开」的牌组规模
ℹ tests 1
ℹ pass 1
ℹ fail 0