3.3 仿真输出的可读化

#!/usr/bin/env python3
# file: sim/gd_mech_03_readable.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/gd_mech_03_readable.py
"""3.3 仿真输出的可读化（S 层）。

轨迹与误差表都是给机器看的。本脚本把它们画成**给眼睛看**的图：一张多局面
血线对比图 out/mech03_hp.svg——**每行一个种子**，行内**每回合一根条**，条长 =
该回合结束时的剩余敌方 HP（分母恒为 params.enemyHp = 50）。一根根条从左到右
就是这条种子下「敌方 HP 从 50 掉到 0」的血线。条长用整数地板除（禁浮点）。

图不是终点：画完必须**回读自证**。用 xml.etree 解析刚写出的 SVG，按
`e.tag.endswith("rect")` 过滤矩形（**坑**：带 xmlns 的 SVG 里 `root.iter("rect")`
匹配不到任何元素，真实标签是 `{http://www.w3.org/2000/svg}rect`），
断言 ① 矩形总数 == 1（背景）+ 2 × 条数（每根条一根底槽 + 一根填充）；
② 带 data-value 的填充矩形，其值序列与每条血线的剩余 HP 逐个相等。

同时落 out/mech03_readable.csv。种子是显式列举的整数，不用 random 模块。
"""
from __future__ import annotations

import os
import sys
import xml.etree.ElementTree as ET

import ashlib

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

SEEDS = [20261014, 1, 7, 42, 100, 999, 123456, 2147483646]
HEADER = ["seed", "dealt", "enemyHpFinal", "turn", "won", "steps", "turns"]


def replay(spec: dict) -> tuple:
    """逐步重放（与 3.1 同一套规则）；额外返回每回合结束时的剩余敌方 HP 血线。"""
    p = spec["params"]
    deck: list = []
    for c in spec["cards"]:
        deck.extend([c] * c["count"])
    deck = ashlib.shuffle_deck(deck, spec["seed"])
    hand = deck[: p["handSize"]]
    draw = deck[p["handSize"]:]
    discard: list = []
    turn, energy = 1, p["energyMax"]
    player_hp, enemy_hp, block, dealt, over, steps = p["playerHp"], p["enemyHp"], 0, 0, False, 0
    line: list = []
    for cmd in spec["strategy"]:
        if over:
            break
        if turn > p["turnLimit"]:
            break
        if cmd.startswith("p"):
            idx = int(cmd[1:])
            if idx < 0 or idx >= len(hand):
                continue
            c = hand[idx]
            if c["cost"] > energy:
                continue
            hand.pop(idx)
            discard.append(c)
            energy -= c["cost"]
            block += c["block"]
            d = min(c["damage"], enemy_hp)
            enemy_hp -= d
            dealt += d
            steps += 1
            if enemy_hp <= 0:
                over = True
        elif cmd == "e":
            absorbed = min(block, p["enemyAttack"])
            block -= absorbed
            player_hp = max(0, player_hp - (p["enemyAttack"] - absorbed))
            steps += 1
            if player_hp <= 0:
                break
            turn += 1
            block = 0
            energy = p["energyMax"]
            while len(hand) < p["handSize"] and draw:
                hand.append(draw.pop(0))
            line.append(enemy_hp)
    if not line or line[-1] != enemy_hp:
        line.append(enemy_hp)
    return dealt, enemy_hp, turn, over and enemy_hp <= 0, steps, line


def build(spec: dict, seeds: list, path: str) -> list:
    """画多局面血线对比图，返回每条血线展平后的剩余 HP（供回读断言）。"""
    W, H = 560, 46 + len(seeds) * 30
    root = ashlib.svg_begin(W, H)
    ashlib.svg_text(root, 16, 24, "ashdeck enemy HP per turn (50 -> 0), one row per seed", 13)
    ashlib.svg_text(root, 150, 24, "turn1 -> last", 11, fill="#94a3b8")
    values: list = []
    for i, seed in enumerate(seeds):
        s = dict(spec)
        s["seed"] = seed
        dealt, _enemy_hp, turn, _won, _steps, line = replay(s)
        y = 46 + i * 30
        ashlib.svg_text(root, 16, y + 12, f"seed {seed}", 11)
        for k, hp in enumerate(line):
            ashlib.svg_bar(root, 150 + k * 36, y, 30, 16, hp, spec["params"]["enemyHp"])
            values.append(hp)
        ashlib.svg_text(root, 150 + len(line) * 36 + 8, y + 12,
                        f"dealt={dealt} T={turn}", 11, fill="#94a3b8")
    ashlib.svg_save(root, path)
    return values


def main() -> int:
    spec = ashlib.load_spec()
    out = os.path.join(ROOT, "out")
    svg_path = os.path.join(out, "mech03_hp.svg")
    values = build(spec, SEEDS, svg_path)

    rows: list = []
    for seed in SEEDS:
        s = dict(spec)
        s["seed"] = seed
        dealt, enemy_hp, turn, won, steps, line = replay(s)
        rows.append([seed, dealt, enemy_hp, turn, str(won).lower(), steps, len(line)])
    n = ashlib.write_csv(os.path.join(out, "mech03_readable.csv"), HEADER, rows)

    tree = ET.parse(svg_path)
    r = tree.getroot()
    naive = list(r.iter("rect"))                      # 坑：命名空间下匹配不到
    rects = [e for e in r.iter() if e.tag.endswith("rect")]
    fills = [e.get("data-value") for e in rects if e.get("data-value") is not None]
    expect_rects = 1 + 2 * len(values)
    ok_count = len(rects) == expect_rects
    ok_values = fills == [str(v) for v in values]

    print(f"seeds={len(SEEDS)} bars={len(values)} svg={os.path.getsize(svg_path)}B")
    print(f"iter('rect')={len(naive)} (namespace pitfall) endswith('rect')={len(rects)}")
    print(f"rects expect={expect_rects} got={len(rects)} ok={ok_count}")
    print(f"data-value={fills}")
    print(f"valuesMatchHpLine={ok_values}")
    print(f"wrote out/mech03_hp.svg out/mech03_readable.csv rows={n}")
    return 0 if ok_count and ok_values and len(naive) == 0 else 1


if __name__ == "__main__":
    sys.exit(main())

seeds=8 bars=30 svg=6879B
iter('rect')=0 (namespace pitfall) endswith('rect')=61
rects expect=61 got=61 ok=True
data-value=['27', '21', '9', '0', '44', '21', '3', '0', '35', '21', '1', '0', '35', '20', '6', '0', '27', '4', '0', '36', '21', '1', '0', '27', '7', '0', '30', '30', '4', '0']
valuesMatchHpLine=True
wrote out/mech03_hp.svg out/mech03_readable.csv rows=8