7.3 三消的节奏

# snippet: sim/gd_proto_07_rhythm.py（节选：分箱与节奏谱绘制）
    chain_max_obs = max(chain_hist)
    step, cmax = rh["clearedStep"], rh["clearedMax"]
    bands, lo = [], 3
    while lo <= cmax:
        hi = min(lo + step - 1, cmax)
        bands.append((f"{lo}-{hi}", lo, hi))
        lo += step
    if max(clear_hist) > cmax:
        bands.append((f"{cmax + 1}+", cmax + 1, max(clear_hist)))
    band_rows = []
    for label, lo, hi in bands:
        n = sum(clear_hist.get(i, 0) for i in range(lo, hi + 1))
        band_rows.append((label, lo, hi, n, 1000 * n // moves))

种子池 256 局 · 6144 步 · 总消除 37981
平均连锁 = 1566‰（1.567）  平均每步消除 = 6181‰（6.182）
每局最长连锁分布（2..10）= [8, 67, 87, 56, 23, 8, 4, 2, 1]
代表种子 70701 的节奏线（每步消除数）= [6, 8, 6, 4, 3, 9, 3, 3, 7, 7, 3, 6, 3, 6, 7, 3, 3, 6, 15, 8, 4, 33, 3, 10]
代表种子 70701 的连锁长度 = [1, 1, 2, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 4, 2, 1, 6, 1, 3]
digest(seed=70701) = {"block":6,"cardCount":49,"damageConserved":true,"dealt":166,"enemyHp":1011,"energy":0,"hand":["1","1","2","1","1","3","1","1","1","2","1","1","1","2","2","1","1","1","4","2","1","6","1","3"],"over":true,"played":24,"playerHp":1989,"turn":24,"won":false}
csv=71 rows  svg=14667 bytes  elapsed=5211 ms
wrote out/proto07_rhythm.csv out/proto07_rhythm.svg out/proto07_rhythm.json

// file: core/test/gd_proto_07_3_rhythm.test.ts
// tier: P
// verify: node --test 'core/test/gd_proto_07_3_rhythm.test.ts'
//
// 卷三 7.3 三消的节奏（P 层）：节奏不是时长，是**每步结算的形状**。本节把「节奏」量成两条
// 整数分布——连锁长度分布（一次交换触发几次连续消除）与每步消除数分布（一次交换总共消掉
// 几格）——用同一批 256 个种子扫出 6144 步，冻结在 TS 侧。S 层 sim/gd_proto_07_rhythm.py 是
// 同一内核的 Python 镜像，两条摘要必须逐字相同（同源异宿主）。节奏指标是**代理指标（proxy）**，
// 只做相对比较，禁绝对化。全整数、无浮点、无 Math.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 { m3Run, m3Digest } from "../genre/match3.ts";

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, "..", "..");
const RH = JSON.parse(readFileSync(join(ROOT, "config", "gd_proto_07_rhythm.json"), "utf8"));
const R = RH.rhythm;
const POOL = Array.from({ length: R.seedCount }, (_, i) => R.seedStart + i);

type Dist = {
  moves: number; cleared: number; meanChain: number; meanCleared: number;
  chain: number[]; chainPm: number[]; maxChainPerSeed: number[];
  clearMax: number; clearSum: number; clearHist: Map<number, number>;
};

/** 一次扫描：固定种子池，只有 rules 在动。全部整数统计。 */
function scan(spec: any): Dist {
  const ch = new Map<number, number>(), cl = new Map<number, number>(), mc = new Map<number, number>();
  let moves = 0, cleared = 0, csum = 0;
  for (const sd of POOL) {
    const s = m3Run({ ...spec, seed: sd });
    for (const c of s.chainCounts) { ch.set(c, (ch.get(c) ?? 0) + 1); csum += c; moves += 1; }
    for (const v of s.clearedPerMove) cl.set(v, (cl.get(v) ?? 0) + 1);
    cleared += s.totalCleared;
    mc.set(s.maxChain, (mc.get(s.maxChain) ?? 0) + 1);
  }
  const cmax = Math.max(...ch.keys());
  let clearSum = 0;
  for (const n of cl.values()) clearSum += n;
  return {
    moves, cleared,
    meanChain: Math.floor((1000 * csum) / moves),
    meanCleared: Math.floor((1000 * cleared) / moves),
    chain: Array.from({ length: cmax }, (_, i) => ch.get(i + 1) ?? 0),
    chainPm: Array.from({ length: cmax }, (_, i) => Math.floor((1000 * (ch.get(i + 1) ?? 0)) / moves)),
    maxChainPerSeed: Array.from({ length: cmax }, (_, i) => mc.get(i + 1) ?? 0),
    clearMax: Math.max(...cl.keys()), clearSum, clearHist: cl,
  };
}

const t0 = process.hrtime.bigint();
const BASE = scan(RH);
const elapsedMs = Number((process.hrtime.bigint() - t0) / 1000000n);

const mutate = (fn: (s: any) => void) => {
  const s = JSON.parse(JSON.stringify(RH));
  fn(s);
  return scan(s);
};

test("基线节奏冻结：256 局 6144 步、总消除 37981、平均连锁 1566‰、平均每步消除 6181‰", () => {
  assert.equal(POOL.length, 256);
  assert.equal(BASE.moves, 6144);
  assert.equal(BASE.cleared, 37981);
  assert.equal(BASE.meanChain, 1566);
  assert.equal(BASE.meanCleared, 6181);
  assert.equal(BASE.chain.length, 10);
});

test("连锁长度分布冻结：1/2/3 层占 950‰，尾巴拖到 10 层", () => {
  assert.deepEqual(BASE.chain, [3929, 1428, 486, 189, 71, 25, 9, 4, 2, 1]);
  assert.deepEqual(BASE.chainPm, [639, 232, 79, 30, 11, 4, 1, 0, 0, 0]);
  const head = BASE.chainPm[0] + BASE.chainPm[1] + BASE.chainPm[2];
  assert.equal(head, 950);
  assert.equal(BASE.chainPm[0] > BASE.chainPm[1], true);
  assert.equal(BASE.chain[9], 1);
});

test("连锁分布单调递减：越长的连锁越罕见（代理指标，只做相对比较）", () => {
  for (let i = 1; i < BASE.chain.length; i += 1) {
    assert.equal(BASE.chain[i] <= BASE.chain[i - 1], true, `第 ${i + 1} 档不递减`);
  }
  assert.equal(BASE.chain[0] > BASE.chain[9] * 100, true);
});

test("每步消除数分布覆盖全部 6144 步，无漏档", () => {
  assert.equal(BASE.clearSum, BASE.moves);
  assert.equal(BASE.clearSum, 6144);
  assert.equal(BASE.clearMax, 50);
  assert.equal(BASE.clearHist.get(3), 2485);
  assert.equal(BASE.clearHist.get(4), 602);
  assert.equal(BASE.clearHist.get(6), 1104);
});

test("每局最长连锁分布冻结：2 层 8 局 / 3 层 67 局 / 4 层 87 局（众数）", () => {
  assert.deepEqual(BASE.maxChainPerSeed, [0, 8, 67, 87, 56, 23, 8, 4, 2, 1]);
  assert.equal(BASE.maxChainPerSeed.reduce((a, b) => a + b, 0), 256);
  assert.equal(BASE.maxChainPerSeed[3], 87);
  assert.equal(BASE.maxChainPerSeed[0], 0);
});

test("代表种子 70701 的节奏线冻结：稀疏的大起伏 + 一次 33 格雪崩", () => {
  const s = m3Run({ ...RH, seed: R.sampleSeed });
  assert.deepEqual(s.clearedPerMove,
    [6, 8, 6, 4, 3, 9, 3, 3, 7, 7, 3, 6, 3, 6, 7, 3, 3, 6, 15, 8, 4, 33, 3, 10]);
  assert.deepEqual(s.chainCounts,
    [1, 1, 2, 1, 1, 3, 1, 1, 1, 2, 1, 1, 1, 2, 2, 1, 1, 1, 4, 2, 1, 6, 1, 3]);
  assert.equal(s.maxChain, 6);
  assert.equal(s.totalCleared, 166);
});

test("同源异宿主：TS 侧与 S 层 Python 镜像的代表种子摘要逐字相同", () => {
  const here = m3Digest(m3Run({ ...RH, seed: R.sampleSeed }));
  const py = JSON.parse(readFileSync(join(ROOT, "out", "proto07_rhythm.json"), "utf8"));
  assert.equal(py.sampleSeed, R.sampleSeed);
  assert.equal(here, py.sampleDigest);
});

test("连锁是节奏的旋钮：cascadeCap 1 → 所有连锁恒为 1 层", () => {
  const r = mutate((s) => { s.rules.cascadeCap = 1; });
  assert.deepEqual(r.chain, [6144]);
  assert.equal(r.meanChain, 1000);
  assert.equal(r.cleared, 35798);
  assert.equal(r.cleared < BASE.cleared, true);
});

test("颜色数是节奏的旋钮：5 → 6 色把平均连锁压到 1323‰、总消除降到 28695", () => {
  const r = mutate((s) => { s.rules.types = 6; });
  assert.equal(r.meanChain, 1323);
  assert.equal(r.meanCleared, 4670);
  assert.equal(r.cleared, 28695);
  assert.equal(r.chain.length, 7);
  assert.equal(r.meanChain < BASE.meanChain, true);
});

test("策略是节奏的旋钮：first 比 max 少消 9445 格、连锁也更短", () => {
  const r = mutate((s) => { s.rules.policy = "first"; });
  assert.equal(r.cleared, 28536);
  assert.equal(r.meanChain, 1415);
  assert.equal(BASE.cleared - r.cleared, 9445);
  assert.equal(r.meanChain < BASE.meanChain, true);
});

test("minRun 3 → 4 会改变节奏，且步数不再是 6144（部分步无可消交换）", () => {
  const r = mutate((s) => { s.rules.minRun = 4; });
  assert.equal(r.cleared, 27604);
  assert.equal(r.meanChain, 1081);
  assert.equal(r.moves < 6144, true);
  assert.equal(r.chain.length, 4);
});

test("扫描是确定性的，且总耗时在分钟级以内", () => {
  assert.equal(elapsedMs < 60000, true);
  const again = scan(RH);
  assert.deepEqual(again.chain, BASE.chain);
  assert.equal(again.cleared, BASE.cleared);
  assert.equal(again.meanChain, BASE.meanChain);
});

✔ 基线节奏冻结：256 局 6144 步、总消除 37981、平均连锁 1566‰、平均每步消除 6181‰
✔ 连锁长度分布冻结：1/2/3 层占 950‰，尾巴拖到 10 层
✔ 连锁分布单调递减：越长的连锁越罕见（代理指标，只做相对比较）
✔ 每步消除数分布覆盖全部 6144 步，无漏档
✔ 每局最长连锁分布冻结：2 层 8 局 / 3 层 67 局 / 4 层 87 局（众数）
✔ 代表种子 70701 的节奏线冻结：稀疏的大起伏 + 一次 33 格雪崩
✔ 同源异宿主：TS 侧与 S 层 Python 镜像的代表种子摘要逐字相同
✔ 连锁是节奏的旋钮：cascadeCap 1 → 所有连锁恒为 1 层
✔ 颜色数是节奏的旋钮：5 → 6 色把平均连锁压到 1323‰、总消除降到 28695
✔ 策略是节奏的旋钮：first 比 max 少消 9445 格、连锁也更短
✔ minRun 3 → 4 会改变节奏，且步数不再是 6144（部分步无可消交换）
✔ 扫描是确定性的，且总耗时在分钟级以内
ℹ tests 12
ℹ suites 0
ℹ pass 12
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 1973.460584