4.3 选择密度与节奏

#!/usr/bin/env python3
# file: sim/nm_04_3_choice_density_rhythm.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/nm_04_3_choice_density_rhythm.py
"""卷三 4.3 选择密度与节奏（S 层）：一条路径上每隔多少节点出现一次「有分量的选择」。

可判定口径（写死在代码里，不按结果调参）：
  1) 选择点 = 路径上除终局节点外的每个对话节点（本规格下全部非终局节点都至少有一个选项，
     故**节点级选择密度恒约为 1000‰**——真正有信息量的是「有分量」那部分）。
  2) 有分量选择 = 该步所选选项**不是状态级假选择**：其推进结果（节点 + 好感度 + flag +
     物品 逐字段）与同节点另一个在该状态下可选的选项**不同**。判据同 4.2。
  3) 选择间隔 = 相邻两个有分量选择之间隔了几个节点（1 = 连续两步都是有分量选择）。
  4) 节奏 = 有分量选择在**三幕**上的分布占比，以及间隔序列的均值 / 极差。

用 Lehmer MINSTD（rng = rng * 48271 % 2147483647）在可用选项里均匀随机采样 500 条路径。
这是一个 **proxy**：密度与间隔是**结构量**，只用于不同规格 / 不同采样策略之间的**相对比较**，
不预测玩家的主观节奏感，也不声称「间隔短 = 体验好」。

产出 out/nm_04_3_density.csv（每条路径一行）与 out/nm_04_3_density.json（汇总）。
"""
from __future__ import annotations

import csv
import json
import os
import sys
from collections import Counter

HERE = os.path.dirname(os.path.abspath(__file__))
LO, HI = 0, 100
SEED = 20261016
N_PATHS = 500


def main() -> int:
    with open(os.path.join(HERE, "../config/story_spec.json"), encoding="utf-8") as fh:
        spec = json.load(fh)
    nodes = spec["dialogue"]
    by = {n["id"]: n for n in nodes}
    start = spec["meta"]["start"]
    vars_ = sorted(spec["state"]["vars"])
    flags = sorted(spec["state"]["flags"])
    items = sorted(spec["state"]["items"])
    act_of_scene = {n["id"]: n.get("act") for n in spec["scene_graph"]["nodes"]}

    def cond_ok(c, s) -> bool:
        if c is None:
            return True
        k = c[0]
        if k == "flag":
            return s["flags"].get(c[1], 0) == c[2]
        if k == "item":
            return s["items"].get(c[1], 0) == c[2]
        if k == "aff":
            v, op, n = s["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 cond_ok(c[1], s) and cond_ok(c[2], s)
        if k == "or":
            return cond_ok(c[1], s) or cond_ok(c[2], s)
        return not cond_ok(c[1], s)

    def apply_eff(eff, s):
        aff, fl, it = dict(s["aff"]), dict(s["flags"]), dict(s["items"])
        for k, v in (eff.get("set") or {}).items():
            fl[k] = v
        for k, v in (eff.get("add") or {}).items():
            aff[k] = LO if aff.get(k, 0) + v < LO else HI if aff.get(k, 0) + v > HI else aff.get(k, 0) + v
        for k, v in (eff.get("grant") or {}).items():
            it[k] = v
        for k in (eff.get("revoke") or {}):
            it[k] = 0
        return aff, fl, it

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

    def advance_key(c, s):
        a, f, i = apply_eff(c.get("effects") or {}, s)
        return (c["goto"], tuple(sorted(a.items())), tuple(sorted(f.items())), tuple(sorted(i.items())))

    def is_fake(c, opts, s) -> bool:
        k = advance_key(c, s)
        return any(o is not c and advance_key(o, s) == k for o in opts)

    rng = SEED
    rows = []
    for p in range(N_PATHS):
        s = init_state()
        steps = 0
        scenes = []
        act_cnt = {1: 0, 2: 0, 3: 0}
        marked = []          # 1 = 有分量选择
        while True:
            cur = by[s["node"]]
            if cur.get("ending"):
                scenes.append(cur["scene"])
                break
            scenes.append(cur["scene"])
            opts = [c for c in (cur.get("choices") or []) if cond_ok(c.get("when"), s)]
            if not opts:
                break
            rng = (rng * 48271) % 2147483647
            c = opts[rng % len(opts)]
            steps += 1
            a = act_of_scene.get(cur["scene"])
            if a in act_cnt:
                act_cnt[a] += 1
            marked.append(0 if is_fake(c, opts, s) else 1)
            aff, fl, it = apply_eff(c.get("effects") or {}, s)
            s = {"node": c["goto"], "aff": aff, "flags": fl, "items": it}
        pos = [i for i, m in enumerate(marked) if m]
        gaps = [b - a for a, b in zip(pos, pos[1:])]
        rows.append({
            "path": p,
            "nodes": len(scenes),
            "choices": steps,
            "scenes": len(set(scenes)),
            "meaningful": len(pos),
            "density_permille": steps * 1000 // len(scenes),
            "meaningful_permille": len(pos) * 1000 // steps if steps else 0,
            "act1": act_cnt[1], "act2": act_cnt[2], "act3": act_cnt[3],
            "max_gap": max(gaps) if gaps else 0,
        })

    n = len(rows)
    tot_nodes = sum(r["nodes"] for r in rows)
    tot_choices = sum(r["choices"] for r in rows)
    tot_mean = sum(r["meaningful"] for r in rows)
    # 全局间隔分布：再采一遍只收间隔（同种子同序列，代价可忽略）
    gap_hist = Counter()
    rng = SEED
    for p in range(N_PATHS):
        s = init_state()
        marked = []
        while True:
            cur = by[s["node"]]
            if cur.get("ending"):
                break
            opts = [c for c in (cur.get("choices") or []) if cond_ok(c.get("when"), s)]
            if not opts:
                break
            rng = (rng * 48271) % 2147483647
            c = opts[rng % len(opts)]
            marked.append(0 if is_fake(c, opts, s) else 1)
            aff, fl, it = apply_eff(c.get("effects") or {}, s)
            s = {"node": c["goto"], "aff": aff, "flags": fl, "items": it}
        pos = [i for i, m in enumerate(marked) if m]
        for a, b in zip(pos, pos[1:]):
            gap_hist[b - a] += 1

    mean_gap_milli = (sum(k * v for k, v in gap_hist.items()) * 1000 //
                      sum(gap_hist.values())) if gap_hist else 0
    max_gap = max(gap_hist) if gap_hist else 0
    act_tot = {1: sum(r["act1"] for r in rows), 2: sum(r["act2"] for r in rows),
               3: sum(r["act3"] for r in rows)}
    act_all = sum(act_tot.values())

    out_dir = os.path.join(HERE, "../out")
    os.makedirs(out_dir, exist_ok=True)
    with open(os.path.join(out_dir, "nm_04_3_density.csv"), "w",
              encoding="utf-8", newline="") as fh:
        w = csv.DictWriter(fh, fieldnames=list(rows[0]))
        w.writeheader()
        w.writerows(rows)

    summary = {
        "paths": n, "seed": SEED,
        "nodes_mean": tot_nodes // n,
        "nodes_min": min(r["nodes"] for r in rows),
        "nodes_max": max(r["nodes"] for r in rows),
        "choices_total": tot_choices,
        "density_permille": tot_choices * 1000 // tot_nodes,
        "meaningful_total": tot_mean,
        "meaningful_permille": tot_mean * 1000 // tot_choices,
        "gap_mean_milli": mean_gap_milli,
        "gap_max": max_gap,
        "gap_hist": {str(k): v for k, v in sorted(gap_hist.items())},
        "act_share_permille": {str(k): act_tot[k] * 1000 // act_all for k in (1, 2, 3)},
        "dry_stretch_paths": sum(1 for r in rows if r["max_gap"] >= 2),
    }
    with open(os.path.join(out_dir, "nm_04_3_density.json"), "w", encoding="utf-8") as fh:
        json.dump(summary, fh, ensure_ascii=False, indent=1)

    ne = sum(1 for nd in nodes if not nd.get("ending"))
    print(f"结构密度：非终局节点 {ne} 个，选项 115 条，平均每节点 {115 * 1000 // ne} 毫个选项")
    print(f"采样 {n} 条路径（seed={SEED}）：节点数 {summary['nodes_min']}/"
          f"{summary['nodes_mean']}/{summary['nodes_max']}（min/mean/max）")
    print(f"选择密度 {summary['density_permille']} 千分（选择点 {tot_choices} / 节点 {tot_nodes}）")
    print(f"有分量选择 {tot_mean} 次，占有分量比例 {summary['meaningful_permille']} 千分")
    print(f"有分量选择的间隔：均值 {mean_gap_milli} 毫（{mean_gap_milli / 1000:.3f} 步） 最大 {max_gap} 步 "
          f"分布 {dict(sorted(gap_hist.items()))}")
    print(f"三幕有分量选择占比 {summary['act_share_permille']}（第一夜/第二夜/第三夜）")
    print(f"存在 >=2 步空档的路径 {summary['dry_stretch_paths']} / {n}")
    print(f"wrote out/nm_04_3_density.csv rows={len(rows)} / .json")

    if tot_choices == 0:
        print("FAIL 采样未走出任何选择")
        return 1
    print("OK nm_04_3_choice_density_rhythm：选择密度与节奏已量出")
    return 0


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

结构密度：非终局节点 43 个，选项 115 条，平均每节点 2674 毫个选项
采样 500 条路径（seed=20261016）：节点数 23/26/32（min/mean/max）
选择密度 962 千分（选择点 12680 / 节点 13180）
有分量选择 11629 次，占有分量比例 917 千分
有分量选择的间隔：均值 1094 毫（1.094 步） 最大 3 步 分布 {1: 10083, 2: 1041, 3: 5}
三幕有分量选择占比 {'1': 433, '2': 296, '3': 270}（第一夜/第二夜/第三夜）
存在 >=2 步空档的路径 486 / 500
wrote out/nm_04_3_density.csv rows=500 / .json
OK nm_04_3_choice_density_rhythm：选择密度与节奏已量出