12.2 条件文本与变体

#!/usr/bin/env python3
# file: sim/na_12_2_conditional_variant.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/na_12_2_conditional_variant.py
"""卷一 12.2 条件文本与变体（S 层）：同一份规格在不同状态下渲染出多少种文本。

对每个带 line_when 的节点，枚举其条件里**自由变量的整个定义域**
（flag / item 取 {0,1}，好感度取 0–100），把状态空间投影成两个计数：

    结构分支 = 渲染器实际走到的分支种类数（base / when / else / fallback）
    文本变体 = 渲染出的不同文本条数

两者之差就是「结构分流了、文本没分流」的缺口。本规格里 d_tc_2 两分支两条
文本，d_lt_2 两分支只有一条——后者是规格层面的欠声明（缺 line_else）。

比较只在同一进程内做，用于计数；跨语言的摘要只对状态做。
"""
from __future__ import annotations

import itertools
import json
import os
import sys

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(HERE)
SPEC = os.path.join(ROOT, "config/story_spec.json")
OUT = os.path.join(ROOT, "out/na_12_2_variant_enum.json")

AFF_LO, AFF_HI = 0, 100
BOOL_DOMAIN = [0, 1]
N_DIALOGUE, N_STATIC = 48, 46
ENUM_CAP = 1024


def load_spec() -> dict:
    with open(SPEC, encoding="utf-8") as fh:
        return json.load(fh)


def eval_cond(c, st: dict) -> bool:
    """条件求值：六种形式，与 na_00 / 内核同语义。"""
    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, "<": v < n, "==": v == n, "!=": v != n}[op]
    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 render_line(node: dict, st: dict) -> tuple[str, str]:
    """四分支渲染规则，与 na_01_line_render.py 同一口径。"""
    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 free_vars(c, out: list) -> None:
    """收集条件里的自由变量（去重、保持出现顺序）。"""
    if c is None:
        return
    k = c[0]
    if k in ("flag", "item", "aff"):
        pair = (k, c[1])
        if pair not in out:
            out.append(pair)
        return
    if k == "not":
        free_vars(c[1], out)
        return
    free_vars(c[1], out)
    free_vars(c[2], out)


def domain(kind: str) -> list:
    return BOOL_DOMAIN if kind in ("flag", "item") else list(range(AFF_LO, AFF_HI + 1))


def base_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 with_assign(base: dict, vars_: list, values: tuple) -> dict:
    st = {"aff": dict(base["aff"]), "flags": dict(base["flags"]), "items": dict(base["items"])}
    for (kind, name), val in zip(vars_, values):
        if kind == "aff":
            st["aff"][name] = val
        elif kind == "flag":
            st["flags"][name] = val
        else:
            st["items"][name] = val
    return st


def enumerate_node(spec: dict, node: dict, base: dict) -> dict:
    """枚举一个节点的整个条件定义域，返回分支分布与渲染结果。"""
    vars_: list = []
    free_vars(node["line_when"], vars_)
    size = 1
    for kind, _ in vars_:
        size *= len(domain(kind))
    if size > ENUM_CAP:
        raise ValueError(f"{node['id']} 枚举上界 {size} 超过 {ENUM_CAP}")

    branch_count: dict[str, int] = {}
    samples: dict[str, dict] = {}
    texts = set()
    combos = list(itertools.product(*[domain(k) for k, _n in vars_])) if vars_ else [()]
    for values in combos:
        st = with_assign(base, vars_, values)
        text, branch = render_line(node, st)
        branch_count[branch] = branch_count.get(branch, 0) + 1
        texts.add(text)
        key = ",".join(f"{n}={v}" for (_k, n), v in zip(vars_, values))
        prev = samples.get(branch)
        if prev is None:
            samples[branch] = {"first": key, "last": key, "text": text}
        else:
            prev["last"] = key
    return {"id": node["id"], "line_when": node["line_when"], "vars": [f"{k}:{n}" for k, n in vars_],
            "states": size, "branches": dict(sorted(branch_count.items())),
            "distinct_texts": len(texts), "samples": samples}


def main() -> int:
    spec = load_spec()
    dlg = spec["dialogue"]
    base = base_state(spec)
    cond_nodes = [n for n in dlg if n.get("line_when")]
    static_nodes = [n for n in dlg if not n.get("line_when")]

    rows = []
    for node in cond_nodes:
        info = enumerate_node(spec, node, base)
        rows.append(info)
        print(f"{info['id']}  line_when={info['line_when']}  自由变量={info['vars']}")
        print(f"  枚举状态 {info['states']} 个 -> 结构分支 {len(info['branches'])} 种 {info['branches']}，"
              f"文本变体 {info['distinct_texts']} 种")
        for branch in sorted(info["samples"]):
            s = info["samples"][branch]
            print(f"    [{s['first']}] {branch}：{s['text']}")
            if s["last"] != s["first"]:
                print(f"    [{s['last']}] {branch}：{s['text']}")

    struct_total = len(static_nodes) + sum(len(r["branches"]) for r in rows)
    variant_total = len(static_nodes) + sum(r["distinct_texts"] for r in rows)
    gap = struct_total - variant_total
    print(f"全规格：静态节点 {len(static_nodes)} 个（各 1 分支 1 变体）")
    print(f"结构分支合计 {struct_total} 种，文本变体合计 {variant_total} 种，"
          f"「结构分流而文本不分流」的缺口 {gap} 处 "
          f"{[r['id'] for r in rows if r['distinct_texts'] < len(r['branches'])]}")

    report = {"static_nodes": len(static_nodes), "conditional_nodes": len(rows),
              "structural_branches": struct_total, "text_variants": variant_total,
              "variant_gap": gap, "nodes": rows}
    os.makedirs(os.path.dirname(OUT), exist_ok=True)
    with open(OUT, "w", encoding="utf-8") as fh:
        json.dump(report, fh, ensure_ascii=False, indent=2)
        fh.write("\n")

    # ---- 整数不变量 ----
    if len(dlg) != N_DIALOGUE or len(static_nodes) != N_STATIC:
        print(f"FAIL 节点数 {len(dlg)} / 静态 {len(static_nodes)} 与预期不符")
        return 1
    for r in rows:
        if sum(r["branches"].values()) != r["states"]:
            print(f"FAIL {r['id']} 分支计数之和 != 枚举状态数")
            return 1
        if r["distinct_texts"] > len(r["branches"]):
            print(f"FAIL {r['id']} 文本变体多于结构分支")
            return 1
    print("OK na_12_2_conditional_variant：d_tc_2 两分支两条文本，d_lt_2 两分支一条文本（欠声明）")
    return 0


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

d_tc_2  line_when=['flag', 'cave_explored', 1]  自由变量=['flag:cave_explored']
  枚举状态 2 个 -> 结构分支 2 种 {'else': 1, 'when': 1}，文本变体 2 种
    [cave_explored=0] else：石壁上刻着名字，一个接一个，刻得很浅。
    [cave_explored=1] when：石壁深处传来一句话，像有人在念自己刻的字：十七个。你是第十八个来的。
d_lt_2  line_when=['aff', 'yan', '>=', 30]  自由变量=['aff:yan']
  枚举状态 101 个 -> 结构分支 2 种 {'fallback': 30, 'when': 71}，文本变体 1 种
    [yan=0] fallback：你来晚了三天。不过，也不算晚。
    [yan=29] fallback：你来晚了三天。不过，也不算晚。
    [yan=30] when：你来晚了三天。不过，也不算晚。
    [yan=100] when：你来晚了三天。不过，也不算晚。
全规格：静态节点 46 个（各 1 分支 1 变体）
结构分支合计 50 种，文本变体合计 49 种，「结构分流而文本不分流」的缺口 1 处 ['d_lt_2']
OK na_12_2_conditional_variant：d_tc_2 两分支两条文本，d_lt_2 两分支一条文本（欠声明）