3.3 确定性战斗结算

// file: proto/src/n03_round.ts
// tier: P
// verify: node --test proto/test/n03.test.ts
// 第 3 章确定性原型：自实现确定性 PRNG（mulberry32）+ 回合结算回放。
// 结算复用 core.ts 的 resolveBattle / damagePerUnit / battleReport；兵种克制矩阵见第 4 章。

import { resolveBattle, battleReport } from "./core.ts";
import type { BattleResult } from "./core.ts";

// 与 sim/n03_random.py 同算法同种子，随机序列逐位一致；不吃运行时随机数实现。
export function mulberry32(seed: number): () => number {
  let a = seed >>> 0;
  return () => {
    a = (a + 0x6D2B79F5) >>> 0;
    let t = Math.imul(a ^ (a >>> 15), a | 1);
    t = (t ^ (t + Math.imul(t ^ (t >>> 7), t | 61))) >>> 0;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

export function firstRolls(seed: number, n: number): string[] {
  const r = mulberry32(seed);
  return Array.from({ length: n }, () => r().toFixed(12));
}

// FNV-1a 32 位：给回放日志算一个可断言、可跨语言对齐的指纹。
export function fnv1a(input: string): number {
  let h = 0x811c9dc5;
  for (let i = 0; i < input.length; i++) {
    h ^= input.charCodeAt(i);
    h = Math.imul(h, 0x01000193) >>> 0;
  }
  return h >>> 0;
}

// 回放日志的规范串：每回合一行，字段用冒号分隔，回合之间用竖线。
export function canonicalLog(r: BattleResult): string {
  return r.log.map((l) => `${l.round}:${l.aHp}:${l.dHp}:${l.aDmg}:${l.dDmg}`).join("|");
}

export function battleReplay(aUnit: string, aCount: number, dUnit: string, dCount: number, terrainPct = 0) {
  const r = resolveBattle(aUnit, aCount, dUnit, dCount, terrainPct);
  const log = canonicalLog(r);
  const hash = fnv1a(log);
  return {
    winner: r.winner,
    rounds: r.rounds,
    aSurvivors: r.aSurvivors,
    dSurvivors: r.dSurvivors,
    aHp: r.aHp,
    dHp: r.dHp,
    logHash: hash,
    logHex: hash.toString(16).padStart(8, "0"),
    log,
  };
}

// 门禁基准战斗：与 sim/bastion_core.py 的 battle_report() 同输入同输出。
export function gateBattle() {
  const b = battleReport().battle;
  return { winner: b.winner, rounds: b.rounds, aSurvivors: b.aSurvivors, aHp: b.aHp, dHp: b.dHp };
}

// file: proto/test/n03.test.ts
// tier: P
// verify: node --test proto/test/n03.test.ts
// 第 3 章断言：确定性回合结算的多回合收敛、回放哈希稳定、与 Python 侧逐位一致。

import { test } from "node:test";
import assert from "node:assert/strict";
import { battleReplay, fnv1a, gateBattle, firstRolls } from "../src/n03_round.ts";

test("3.2 确定性 PRNG：前 5 个随机数与 Python 逐位一致", () => {
  assert.deepEqual(firstRolls(20261012, 5), [
    "0.341123865684", "0.017803263851", "0.364578908775", "0.008977568476", "0.681191388052",
  ]);
});

test("3.3 多回合结算：枪兵 300 对骑兵 300，3 回合，胜者 a", () => {
  const r = battleReplay("spearman", 300, "cavalry", 300, 0);
  assert.equal(r.winner, "a");
  assert.equal(r.rounds, 3);
  assert.equal(r.aSurvivors, 123);
  assert.equal(r.dSurvivors, 0);
  assert.equal(r.aHp, 48900);
  assert.equal(r.dHp, 0);
});

test("3.3 回放哈希稳定：同输入两次运行同哈希", () => {
  const r1 = battleReplay("spearman", 300, "cavalry", 300, 0);
  const r2 = battleReplay("spearman", 300, "cavalry", 300, 0);
  assert.equal(r1.logHash, r2.logHash);
  assert.equal(r1.logHash, 1910851607);
  assert.equal(r1.logHex, "71e54817");
});

test("3.3 地形加成改变结算：terrain=15 时提前到 2 回合结束", () => {
  const r = battleReplay("spearman", 300, "cavalry", 300, 15);
  assert.equal(r.winner, "a");
  assert.equal(r.rounds, 2);
  assert.equal(r.aSurvivors, 145);
  assert.equal(r.logHash, 1742504974);
});

test("3.3 与 Python 侧逐位一致：core 门禁基准 battle（骑兵对弓兵）", () => {
  const b = gateBattle();
  assert.equal(b.winner, "a");
  assert.equal(b.rounds, 1);
  assert.equal(b.aSurvivors, 171);
  assert.equal(b.aHp, 61500);
  assert.equal(b.dHp, 0);
});

test("3.3 fnv1a 基础向量：空串 = 0x811c9dc5", () => {
  assert.equal(fnv1a(""), 0x811c9dc5);
  assert.equal(fnv1a(""), 2166136261);
});

✔ 3.2 确定性 PRNG：前 5 个随机数与 Python 逐位一致
✔ 3.3 多回合结算：枪兵 300 对骑兵 300，3 回合，胜者 a
✔ 3.3 回放哈希稳定：同输入两次运行同哈希
✔ 3.3 地形加成改变结算：terrain=15 时提前到 2 回合结束
✔ 3.3 与 Python 侧逐位一致：core 门禁基准 battle（骑兵对弓兵）
✔ 3.3 fnv1a 基础向量：空串 = 0x811c9dc5
ℹ tests 6  ℹ pass 6  ℹ fail 0

# file: sim/n03_round_cross.py
# tier: S
# verify: python3 sim/n03_round_cross.py
"""确定性回合结算的 Python 侧对照：复用 bastion_core.resolve_battle，产出与 proto 侧逐位一致的日志与指纹。

产出：out/n03_round_cross.json
"""

from __future__ import annotations

import json
import os
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import bastion_core as core  # noqa: E402

OUT = os.path.join(HERE, "..", "out")


def fnv1a(s: str) -> int:
    h = 0x811c9dc5
    for ch in s.encode("ascii"):
        h = ((h ^ ch) * 0x01000193) & 0xFFFFFFFF
    return h


def canonical_log(r: dict) -> str:
    return "|".join(f"{l['round']}:{l['aHp']}:{l['dHp']}:{l['aDmg']}:{l['dDmg']}" for l in r["log"])


def replay(a_unit, a_count, d_unit, d_count, terrain_pct=0) -> dict:
    r = core.resolve_battle(a_unit, a_count, d_unit, d_count, terrain_pct)
    log = canonical_log(r)
    h = fnv1a(log)
    return {
        "winner": r["winner"], "rounds": r["rounds"],
        "aSurvivors": r["aSurvivors"], "dSurvivors": r["dSurvivors"],
        "aHp": r["aHp"], "dHp": r["dHp"],
        "logHash": h, "logHex": format(h, "08x"), "log": log,
    }


def main() -> int:
    report = {
        "spearman300_vs_cavalry300": replay("spearman", 300, "cavalry", 300, 0),
        "spearman300_vs_cavalry300_terrain15": replay("spearman", 300, "cavalry", 300, 15),
        "gate_cavalry300_vs_archer300": replay("cavalry", 300, "archer", 300, 0),
    }
    os.makedirs(OUT, exist_ok=True)
    with open(os.path.join(OUT, "n03_round_cross.json"), "w", encoding="utf-8") as f:
        json.dump(report, f, ensure_ascii=False, indent=2)
    print(json.dumps(report, ensure_ascii=False))
    return 0


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

{"spearman300_vs_cavalry300": {"winner": "a", "rounds": 3, "aSurvivors": 123, "aHp": 48900,
  "logHash": 1910851607, "logHex": "71e54817", ...},
 "spearman300_vs_cavalry300_terrain15": {"rounds": 2, "aSurvivors": 145, "logHex": "67dc840e", ...},
 "gate_cavalry300_vs_archer300": {"rounds": 1, "aSurvivors": 171, "logHex": "6395cd39", ...}}