6.1 情感曲线的构造

#!/usr/bin/env python3
# file: sim/nm_06_1_emotion_curve_construction.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/nm_06_1_emotion_curve_construction.py
"""卷三 6.1 情感曲线的构造（S 层）。

一条路径 → 经过的节点 → 场景序列 → 节拍序列 → 张力序列（情感曲线）。
张力的唯一真源是 beats[].tension（整数 1–5），本脚本只做「路径 → 曲线」这一步
构造，不做任何文本处理，全程整数。

与 nm_00_toc_metric.py 分工：那个给一页摘要（曲线 + 覆盖率 + 熵三件套）；本脚本
只把「曲线怎么从路径长出来」单独量清楚——场景序列、节拍序列、张力序列，以及曲线
的形状统计（和 / 长度 / 千分位均值 / 极值）。

与《游戏设计》卷二 gd-play-09-2 的分工：那条曲线由机制动力学（HP / 资源 / 回合
节奏）仿真算出；本条曲线由作者标注的叙事节拍沿玩家路径的序列读出。
"""
from __future__ import annotations

import json
import os
import sys

AFF_LO, AFF_HI = 0, 100
HERE = os.path.dirname(os.path.abspath(__file__))
OUT = os.path.join(HERE, "../out")


def cond_ok(c, s):
    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)          # not


def node(spec, nid):
    return next(n for n in spec["dialogue"] if n["id"] == nid)


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


def step(spec, s, c):
    eff = c.get("effects") or {}
    aff, flags, items = dict(s["aff"]), dict(s["flags"]), dict(s["items"])
    for k, v in (eff.get("set") or {}).items():
        flags[k] = v
    for k, v in (eff.get("add") or {}).items():
        aff[k] = min(AFF_HI, max(AFF_LO, aff.get(k, 0) + v))
    for k, v in (eff.get("grant") or {}).items():
        items[k] = v
    for k in (eff.get("revoke") or {}):
        items[k] = 0
    return {"node": c["goto"], "aff": aff, "flags": flags, "items": items,
            "path": s["path"] + [c["goto"]]}


def walk(spec):
    """确定性策略：每步选第一个条件成立的选项。同 nm_00_toc_metric.py。"""
    s = init_state(spec)
    for _ in range(64):
        cur = node(spec, 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
        s = step(spec, s, opts[0])
    return s


def collapse(seq):
    """去掉连续重复，保留「第一次踏入某场景」的先后顺序。"""
    out = []
    for x in seq:
        if not out or out[-1] != x:
            out.append(x)
    return out


def main() -> int:
    with open(os.path.join(HERE, "../config/story_spec.json"), encoding="utf-8") as fh:
        spec = json.load(fh)

    s = walk(spec)
    path = s["path"]

    raw_scenes = [node(spec, nid)["scene"] for nid in path]
    scene_seq = collapse(raw_scenes)
    visited = set(scene_seq)

    beats = spec["beats"]
    beat_seq = [b for b in beats if b["scene"] in visited]        # 节拍真源顺序
    curve = [b["tension"] for b in beat_seq]                      # 情感曲线 = 张力序列
    n = len(curve)
    total = sum(curve)
    mean_permille = total * 1000 // n if n else 0

    print(f"真源         {os.path.basename(spec['meta']['code'])}  {spec['meta']['title']}")
    print(f"起点         {spec['meta']['start']}   节点数 {len(path)}   终局 {s['node']}")
    print(f"节点→场景    {len(path)} 个节点落到 {len(raw_scenes)} 个场景槽（含连续重复）")
    print(f"覆盖场景     {len(visited)} / {len(spec['scene_graph']['nodes'])}（去重后）")
    print(f"场景序列     {len(scene_seq)} 槽（去连续重复）：{' → '.join(scene_seq)}")
    print(f"节拍序列     {' '.join(b['id'] for b in beat_seq)}")
    print(f"张力序列     {' '.join(str(v) for v in curve)}")
    print(f"曲线长度     {n}  （覆盖节拍 {n} / {len(beats)}）")
    print(f"张力之和     {total}")
    print(f"均值千分位   {mean_permille} 毫  （{total} × 1000 // {n}）")
    print(f"极值         min={min(curve)}  max={max(curve)}  （真源 tension ∈ 1–5）")

    # 整数不变量：tension ∈ [1,5]，曲线长度 = 命中节拍数
    assert all(1 <= v <= 5 for v in curve), "tension 越界"
    assert n == sum(1 for b in beats if b["scene"] in visited)

    os.makedirs(OUT, exist_ok=True)
    with open(os.path.join(OUT, "nm_06_1_curve.json"), "w", encoding="utf-8") as fh:
        json.dump({"nodes": len(path), "ending": node(spec, s["node"]).get("ending", ""),
                   "scenes": scene_seq, "scene_unique": len(visited),
                   "beats": [b["id"] for b in beat_seq],
                   "curve": curve, "sum": total, "mean_permille": mean_permille,
                   "min": min(curve), "max": max(curve)},
                  fh, ensure_ascii=False, indent=1)
        fh.write("\n")
    print("wrote out/nm_06_1_curve.json")
    print("OK nm_06_1_emotion_curve_construction：路径 → 场景 → 节拍 → 张力序列已构造")
    return 0


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

真源         mistport  雾港夜航
起点         d_pier_1   节点数 26   终局 e_lit
节点→场景    26 个节点落到 26 个场景槽（含连续重复）
覆盖场景     9 / 14（去重后）
场景序列     11 槽（去连续重复）：pier → tavern → pier → counting_house → watch_post → lighthouse_base → tide_cave → harbor_office → pier → lighthouse_top → dawn_quay
节拍序列     b01 b02 b04 b05 b06 b07 b09 b11 b12 b15 b16
张力序列     1 2 3 2 3 4 4 3 4 4 2
曲线长度     11  （覆盖节拍 11 / 16）
张力之和     32
均值千分位   2909 毫  （32 × 1000 // 11）
极值         min=1  max=4  （真源 tension ∈ 1–5）
wrote out/nm_06_1_curve.json
OK nm_06_1_emotion_curve_construction：路径 → 场景 → 节拍 → 张力序列已构造