11.3 数值的可复现

{"block":0,"cardCount":12,"damageConserved":true,"dealt":50,"enemyHp":0,"energy":1,"hand":["strike","jab","heavy"],"over":true,"played":9,"playerHp":48,"turn":4,"won":true}

#!/usr/bin/env python3
# file: sim/gd_mech_11_reproducibility.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/gd_mech_11_reproducibility.py
"""11.3 数值的可复现（S 层）。

可复现分两层，断言口径完全不同：

  机制层（整数）：digest 是纯整数 / 布尔 / 字符串数组的规范化 JSON，
                  跨语言必须**逐字相等**——这是可以写「逐位一致」的地方。
  表现层（浮点）：像素位移等派生量由宿主浮点库算出，浮点加法不满足结合律，
                  同一组数换个求和顺序末位就不同，因此**只能按声明容差断言**，
                  正文与断言都**禁写「逐位相等」**。

本脚本打印机制层的 digest 字符串（TS 侧 digestSnap 必须给出同一串），
并给一个表现层的反例：三段位移按两种顺序求和，结果不相等，但落在容差内。
"""
from __future__ import annotations

import os

import ashlib

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)

# 表现层容差：像素级视觉差 ≤ 1e-6 px 即肉眼不可辨。
PIXEL_TOL = 1e-6
# 伤害数字的三段屏幕位移（浮点，属表现层，不在 config/ 的整数域内）。
SEGMENTS = [18.4, 6.7, 2.9]


def main() -> int:
    spec = ashlib.load_spec()
    snap = ashlib.run_spec(spec)
    digest = ashlib.digest(snap)

    out = os.path.join(ROOT, "out", "mech11_digest.txt")
    os.makedirs(os.path.dirname(out), exist_ok=True)
    with open(out, "w", encoding="utf-8") as f:
        f.write(digest + "\n")

    print(f"digest={digest}")
    print(f"digest_len={len(digest)}")
    print(f"snap_turn={snap['turn']} snap_won={str(snap['won']).lower()} "
          f"snap_dealt={snap['dealt']} snap_cardCount={snap['cardCount']}")

    left = (SEGMENTS[0] + SEGMENTS[1]) + SEGMENTS[2]
    right = SEGMENTS[0] + (SEGMENTS[1] + SEGMENTS[2])
    delta = abs(left - right)
    print(f"perceptual_left={left!r}")
    print(f"perceptual_right={right!r}")
    print(f"perceptual_equal={left == right}")
    print(f"perceptual_delta={delta!r} tol={PIXEL_TOL!r} within_tol={delta <= PIXEL_TOL}")
    print(f"wrote out/mech11_digest.txt bytes={os.path.getsize(out)}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

digest={"block":0,"cardCount":12,"damageConserved":true,"dealt":50,"enemyHp":0,"energy":1,"hand":["strike","jab","heavy"],"over":true,"played":9,"playerHp":48,"turn":4,"won":true}
digest_len=172
snap_turn=4 snap_won=true snap_dealt=50 snap_cardCount=12
perceptual_left=27.999999999999996
perceptual_right=28.0
perceptual_equal=False
perceptual_delta=3.552713678800501e-15 tol=1e-06 within_tol=True
wrote out/mech11_digest.txt bytes=173

// file: core/test/gd_mech_11_reproducibility.test.ts
// tier: P
// verify: node --test 'core/test/gd_mech_11_reproducibility.test.ts'
//
// 11.3 数值的可复现：机制层（整数）必须逐字相等，表现层（浮点）只能按容差断言。
//   机制层：digestSnap(runSpec(spec)) 必须与 Python 侧 ashlib.digest 给出同一串。
//   表现层：同一组位移换个求和顺序末位就变，故断言「落在容差内」而非「相等」。

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 { digestSnap } from "../src/ashdeck/digest.ts";
import type { Spec } from "../src/ashdeck/types.ts";

const HERE = dirname(fileURLToPath(import.meta.url));
const SPEC: Spec = JSON.parse(
  readFileSync(join(HERE, "..", "..", "config", "play_spec.json"), "utf8"),
);

// 与 sim/gd_mech_11_reproducibility.py 的实跑输出逐字相同。
const PY_DIGEST =
  '{"block":0,"cardCount":12,"damageConserved":true,"dealt":50,"enemyHp":0,' +
  '"energy":1,"hand":["strike","jab","heavy"],"over":true,"played":9,' +
  '"playerHp":48,"turn":4,"won":true}';

const PIXEL_TOL = 1e-6;

test("机制层：digest 与 Python 侧逐字相等（可写「逐位一致」）", () => {
  const d = digestSnap(runSpec(SPEC));
  assert.equal(d, PY_DIGEST);
  assert.equal(d.length, 172);
  assert.equal(d, digestSnap(runSpec(SPEC))); // 再跑一遍，纯函数恒等
});

test("机制层：digest 只含整数 / 布尔 / 字符串数组，无浮点", () => {
  const snap = runSpec(SPEC);
  for (const v of [snap.turn, snap.energy, snap.playerHp, snap.enemyHp,
    snap.block, snap.dealt, snap.played, snap.cardCount]) {
    assert.equal(Number.isInteger(v), true);
  }
  assert.equal(Number.isInteger(snap.won), false); // 布尔不是整数
});

test("表现层：浮点求和顺序不同结果不同，只能按容差断言", () => {
  const seg = [18.4, 6.7, 2.9];
  const left = (seg[0] + seg[1]) + seg[2];
  const right = seg[0] + (seg[1] + seg[2]);
  assert.notEqual(left, right); // 禁写「逐位相等」
  assert.equal(Math.abs(left - right) <= PIXEL_TOL, true);
  assert.equal(left, 27.999999999999996);
  assert.equal(right, 28);
});

test("表现层容差断言本身要有反面：超容差必须判失败", () => {
  const a = 28.0;
  const b = 28.01;
  assert.equal(Math.abs(a - b) <= PIXEL_TOL, false);
});

✔ 机制层：digest 与 Python 侧逐字相等（可写「逐位一致」） (0.685625ms)
✔ 机制层：digest 只含整数 / 布尔 / 字符串数组，无浮点 (0.094875ms)
✔ 表现层：浮点求和顺序不同结果不同，只能按容差断言 (0.171375ms)
✔ 表现层容差断言本身要有反面：超容差必须判失败 (0.068959ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0