1.3 文本是渲染：规格与文本的分工

node   : d_tc_2   scene: tide_cave   speaker: narrator
line   : 石壁深处传来一句话，像有人在念自己刻的字：十七个。你是第十八个来的。
line_when: ["flag", "cave_explored", 1]
line_else: 石壁上刻着名字，一个接一个，刻得很浅。

#!/usr/bin/env python3
# file: sim/na_01_line_render.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/na_01_line_render.py
"""「文本是规格的渲染产物」：同一条 dialogue 记录在不同状态下渲染出不同台词。

本脚本只做**结构**，不评价文本好坏、不比对文风：
  1) 声明渲染规则（line_when → line / line_else / 回落），并逐字执行；
  2) 用 d_tc_2 做最小演示：同一节点、两个状态、两条不同台词；
  3) 反向断言：**文本不进状态**——所有条件里的字符串叶子没有一个等于任何台词。
"""
from __future__ import annotations

import json
import os
import sys

AFF_LO, AFF_HI = 0, 100


def load_spec() -> dict:
    here = os.path.dirname(os.path.abspath(__file__))
    with open(os.path.join(here, "../config/story_spec.json"), encoding="utf-8") as fh:
        return json.load(fh)


def eval_cond(c, st: dict) -> bool:
    """与 na_00_spec_check.py 同一份文法（只求值，不判定可满足性）。"""
    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 = st["aff"].get(c[1], 0)
        op, n = c[2], c[3]
        if op == ">=":
            return v >= n
        if op == "<":
            return v < n
        if op == "==":
            return v == n
        return 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)
    if k == "not":
        return not eval_cond(c[1], st)
    raise ValueError(f"unknown cond op: {k}")


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


def render_line(node: dict, st: dict) -> tuple[str, str]:
    """渲染规则（本套对「条件文本」的唯一口径）：

    line_when 为 null          -> 渲染 line          （分支 base）
    line_when 为真             -> 渲染 line          （分支 when）
    line_when 为假且有 line_else -> 渲染 line_else   （分支 else）
    line_when 为假且无 line_else -> 渲染 line        （分支 fallback，规格未给 else）
    """
    if node.get("line_when") is None:
        return node["line"], "base"
    if eval_cond(node["line_when"], st):
        return node["line"], "when"
    if node.get("line_else"):
        return node["line_else"], "else"
    return node["line"], "fallback"


def cond_strings(c, out: list[str]) -> None:
    """收集条件里的全部字符串叶子，用于「文本不进状态」的反向断言。"""
    if c is None:
        return
    if isinstance(c, str):
        out.append(c)
        return
    if isinstance(c, list):
        for x in c:
            cond_strings(x, out)


def main() -> int:
    spec = load_spec()
    dlg = spec["dialogue"]
    by_id = {n["id"]: n for n in dlg}

    node = by_id["d_tc_2"]
    print(f"演示节点 d_tc_2  line_when={node['line_when']}")
    print(f"  规格里的 line      ：{node['line']}")
    print(f"  规格里的 line_else ：{node.get('line_else')}")

    st_off = init_state(spec)
    st_on = init_state(spec)
    st_on["flags"]["cave_explored"] = 1

    line_off, branch_off = render_line(node, st_off)
    line_on, branch_on = render_line(node, st_on)
    print(f"  状态 A（cave_explored=0）-> 分支 {branch_off}：{line_off}")
    print(f"  状态 B（cave_explored=1）-> 分支 {branch_on}：{line_on}")
    same = line_off == line_on
    print(f"  两条台词是否相同：{same}（长度 {len(line_off)} / {len(line_on)}）")
    if same:
        print("FAIL 同一节点在两个状态下渲染出了同一条台词")
        return 1

    cond_lines = [n["id"] for n in dlg if n.get("line_when")]
    with_else = [n["id"] for n in dlg if n.get("line_else")]
    no_else = [n["id"] for n in dlg if n.get("line_when") and not n.get("line_else")]
    print(f"规格规模：对话节点 {len(dlg)}，带 line_when 的 {len(cond_lines)} 个 {cond_lines}")
    print(f"          其中显式给 line_else 的 {len(with_else)} 个，未给 else 的 {len(no_else)} 个 {no_else}")

    # 反向断言：文本不进状态。条件里出现的字符串叶子不得等于任何台词。
    texts = {n["line"] for n in dlg} | {n["line_else"] for n in dlg if n.get("line_else")}
    leaves: list[str] = []
    for n in dlg:
        cond_strings(n.get("line_when"), leaves)
        for c in (n.get("choices") or []):
            cond_strings(c.get("when"), leaves)
    for e in spec["scene_graph"]["edges"]:
        cond_strings(e.get("when"), leaves)
    for loc in spec["world"]["locations"]:
        cond_strings(loc.get("unlock_when"), leaves)
    for e in spec["endings"]:
        cond_strings(e.get("when"), leaves)
    hit = sorted(set(leaves) & texts)
    print(f"条件字符串叶子 {len(set(leaves))} 个，与台词集合的交集 {len(hit)} 个 {hit}")
    if hit:
        print("FAIL 台词文本出现在条件里（文本进入了状态输入端）")
        return 1

    # 整数不变量
    for c in spec["characters"]:
        assert AFF_LO <= c["affinity"]["init"] <= AFF_HI, f"{c['id']} init 越界"
    print("OK na_01_line_render：一条规格记录渲染出两条台词，文本不进状态")
    return 0


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

演示节点 d_tc_2  line_when=['flag', 'cave_explored', 1]
  规格里的 line      ：石壁深处传来一句话，像有人在念自己刻的字：十七个。你是第十八个来的。
  规格里的 line_else ：石壁上刻着名字，一个接一个，刻得很浅。
  状态 A（cave_explored=0）-> 分支 else：石壁上刻着名字，一个接一个，刻得很浅。
  状态 B（cave_explored=1）-> 分支 when：石壁深处传来一句话，像有人在念自己刻的字：十七个。你是第十八个来的。
  两条台词是否相同：False（长度 19 / 34）
规格规模：对话节点 48，带 line_when 的 2 个 ['d_tc_2', 'd_lt_2']
          其中显式给 line_else 的 1 个，未给 else 的 1 个 ['d_lt_2']
条件字符串叶子 29 个，与台词集合的交集 0 个 []
OK na_01_line_render：一条规格记录渲染出两条台词，文本不进状态