11.2 台词的条件渲染

#!/usr/bin/env python3
# file: sim/na_11_2_line_render_branches.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/na_11_2_line_render_branches.py
"""卷一 11.2 台词的条件渲染（S 层）：把「同一节点在不同状态下渲染出哪条台词」
枚举成一张渲染分支表。

渲染规则（本套对条件文本的唯一口径）：
  line_when 为 null            -> 渲染 line      分支 base
  line_when 为真               -> 渲染 line      分支 when
  line_when 为假且有 line_else -> 渲染 line_else 分支 else
  line_when 为假且无 line_else -> 渲染 line      分支 fallback（规格未给 else）

对 48 个节点逐个枚举渲染分支：46 个无条件节点各 1 支，2 个带 line_when 的节点各 2 支。
d_tc_2 给了 line_else（when / else 两支文本不同）；d_lt_2 没给 line_else（when / fallback
落到同一条文本）——这是**规格层面的欠声明**，修法是补 line_else。

产出 out/na_11_2_line_render.csv。整数不变量：全部节点的 line 非空。
"""
from __future__ import annotations

import csv
import json
import os
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
OUT = os.path.join(ROOT, "out")
CSV_PATH = os.path.join(OUT, "na_11_2_line_render.csv")


def load_spec():
    with open(os.path.join(ROOT, "config/story_spec.json"), encoding="utf-8") as fh:
        return json.load(fh)


def eval_cond(c, st):
    if c is None:
        return True
    k = c[0]
    if k == "flag":
        return st["flags"].get(c[1], 0) == c[2]
    if k == "item":
        return st["items"].get(c[1], 0) == c[2]
    if k == "aff":
        v, op, n = st["aff"].get(c[1], 0), c[2], c[3]
        return (v >= n) if op == ">=" else (v < n) if op == "<" else (v == n) if op == "==" else (v != n)
    if k == "and":
        return eval_cond(c[1], st) and eval_cond(c[2], st)
    if k == "or":
        return eval_cond(c[1], st) or eval_cond(c[2], st)
    return not eval_cond(c[1], st)


def init_state(spec):
    aff = {v: next(c["affinity"]["init"] for c in spec["characters"] if c["id"] == v)
           for v in sorted(spec["state"]["vars"])}
    return {"aff": aff, "flags": {f: 0 for f in sorted(spec["state"]["flags"])},
            "items": {i: 0 for i in sorted(spec["state"]["items"])}}


def render(node, st):
    """返回 (分支名, 渲染出的台词)。"""
    if node.get("line_when") is None:
        return "base", node["line"]
    if eval_cond(node["line_when"], st):
        return "when", node["line"]
    if node.get("line_else"):
        return "else", node["line_else"]
    return "fallback", node["line"]


def force(c, st, want):
    """把状态改造成使条件 c 求值为 want。本规格的 line_when 只有两种叶子：
    flag 叶子与 aff>= 叶子；其余形式一旦出现就断言失败（规格演化时的显式护栏）。"""
    if c[0] == "flag":
        st["flags"][c[1]] = c[2] if want else 1 - c[2]
    else:
        assert c[0] == "aff" and c[2] == ">=", f"未预期的 line_when 形式 {c}"
        st["aff"][c[1]] = c[3] if want else max(0, c[3] - 1)


def main() -> int:
    spec = load_spec()
    dlg = spec["dialogue"]
    base = init_state(spec)
    cond_nodes = [n for n in dlg if n.get("line_when")]
    rows, branch_total = [], 0

    for n in dlg:
        if n.get("line_when") is None:
            branch_total += 1
            rows.append({"node": n["id"], "branch": "base", "line_when": "", "text_len": len(n["line"])})
            continue
        low = {"aff": dict(base["aff"]), "flags": dict(base["flags"]), "items": dict(base["items"])}
        high = {"aff": dict(base["aff"]), "flags": dict(base["flags"]), "items": dict(base["items"])}
        force(n["line_when"], low, False)
        force(n["line_when"], high, True)
        b_low, t_low = render(n, low)
        b_high, t_high = render(n, high)
        branch_total += len({b_low, b_high})
        for br, tx in ((b_low, t_low), (b_high, t_high)):
            rows.append({"node": n["id"], "branch": br,
                         "line_when": json.dumps(n["line_when"], ensure_ascii=False), "text_len": len(tx)})
        same = t_low == t_high
        print(f"条件节点 {n['id']}：line_when={json.dumps(n['line_when'], ensure_ascii=False)}"
              f"  line_else={'有' if n.get('line_else') else '无'}")
        print(f"  条件不成立 -> 分支 {b_low}（{len(t_low)} 字）：{t_low}")
        print(f"  条件成立   -> 分支 {b_high}（{len(t_high)} 字）：{t_high}")
        print(f"  两支文本相同：{same}"
              + ("（规格欠声明：声明了 line_when 却没给 line_else，回落到 line）" if same else ""))

    print(f"节点 {len(dlg)} 个，其中带 line_when 的 {len(cond_nodes)} 个 {[n['id'] for n in cond_nodes]}")
    print(f"渲染分支总数 {branch_total}（46 个无条件节点各 1 支 + 2 个条件节点各 2 支 = 50）")
    assert branch_total == 50, f"分支总数应为 50，实为 {branch_total}"

    for n in dlg:
        assert n["line"].strip(), f"{n['id']} 的 line 为空"
    print("整数不变量：48 个节点 line 均非空；line_when 的 aff 门限 ∈ [0,100] 由 force 断言兜住")

    os.makedirs(OUT, exist_ok=True)
    with open(CSV_PATH, "w", encoding="utf-8", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=["node", "branch", "line_when", "text_len"])
        w.writeheader()
        w.writerows(rows)
    print(f"wrote out/na_11_2_line_render.csv rows={len(rows)}")
    print("OK na_11_2_line_render_branches：渲染分支枚举完整，欠声明节点已点名")
    return 0


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

条件节点 d_tc_2：line_when=["flag", "cave_explored", 1]  line_else=有
  条件不成立 -> 分支 else（19 字）：石壁上刻着名字，一个接一个，刻得很浅。
  条件成立   -> 分支 when（34 字）：石壁深处传来一句话，像有人在念自己刻的字：十七个。你是第十八个来的。
  两支文本相同：False
条件节点 d_lt_2：line_when=["aff", "yan", ">=", 30]  line_else=无
  条件不成立 -> 分支 fallback（15 字）：你来晚了三天。不过，也不算晚。
  条件成立   -> 分支 when（15 字）：你来晚了三天。不过，也不算晚。
  两支文本相同：True（规格欠声明：声明了 line_when 却没给 line_else，回落到 line）
节点 48 个，其中带 line_when 的 2 个 ['d_tc_2', 'd_lt_2']
渲染分支总数 50（46 个无条件节点各 1 支 + 2 个条件节点各 2 支 = 50）
整数不变量：48 个节点 line 均非空；line_when 的 aff 门限 ∈ [0,100] 由 force 断言兜住
wrote out/na_11_2_line_render.csv rows=50
OK na_11_2_line_render_branches：渲染分支枚举完整，欠声明节点已点名

node,branch,line_when,text_len
d_pier_1,base,,18
d_pier_2,base,,35
...
d_tc_2,else,"[""flag"", ""cave_explored"", 1]",19
d_tc_2,when,"[""flag"", ""cave_explored"", 1]",34
...
d_lt_2,fallback,"[""aff"", ""yan"", "">="", 30]",15
d_lt_2,when,"[""aff"", ""yan"", "">="", 30]",15