1.1 世界、角色、事件、选择

#!/usr/bin/env python3
# file: sim/na_01_world_scale.py
# tier: S
# verify: /opt/homebrew/bin/python3 sim/na_01_world_scale.py
"""《雾港夜航》四个最小构成的规模清点：世界 / 角色 / 事件 / 选择。

只读 config/story_spec.json，不做任何推断：四类计数全部直接来自字段长度。
任何一段缺失即 KeyError 退出（exit != 0），因此本脚本同时是一次「骨架存在性」校验。
"""
from __future__ import annotations

import json
import os
import sys

AFF_LO, AFF_HI = 0, 100
TENSION_LO, TENSION_HI = 1, 5


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 count_world(world: dict) -> dict:
    """世界：派系与它们的相互立场、地点、设定条目、世界规则。"""
    factions = world["factions"]
    return {
        "factions": len(factions),
        "stance_cells": sum(len(f["stance"]) for f in factions),
        "locations": len(world["locations"]),
        "locations_locked": sum(1 for loc in world["locations"] if loc.get("unlock_when")),
        "lore": len(world["lore"]),
        "rules": len(world["rules"]),
    }


def count_characters(chars: list[dict]) -> dict:
    """角色：目标 / 恐惧 / 秘密是三个平级列表，弧光另有两个列表。"""
    return {
        "characters": len(chars),
        "goals": sum(len(c["goals"]) for c in chars),
        "fears": sum(len(c["fears"]) for c in chars),
        "secrets": sum(1 for c in chars if c.get("secret")),
        "arc_stages": sum(len(c["arc"]["stages"]) for c in chars),
        "arc_beats": sum(len(c["arc"]["beats"]) for c in chars),
        "thresholds": sum(len(c["affinity"]["thresholds"]) for c in chars),
    }


def count_events(spec: dict) -> dict:
    """事件：幕 / 节拍 / 场景图 / 对话节点。四者是同一条时间轴的不同粒度。"""
    graph = spec["scene_graph"]
    edges = graph["edges"]
    nodes = spec["dialogue"]
    return {
        "acts": spec["meta"]["acts"],
        "beats": len(spec["beats"]),
        "scenes": len(graph["nodes"]),
        "edges": len(edges),
        "edges_unconditional": sum(1 for e in edges if not e.get("when")),
        "edges_conditional": sum(1 for e in edges if e.get("when")),
        "dialogue_nodes": len(nodes),
        "ending_nodes": sum(1 for n in nodes if n.get("ending")),
    }


def count_choices(nodes: list[dict]) -> dict:
    """选择：选项总数、条件选项、以及「有选项的节点 / 无选项的节点」。"""
    total = 0
    conditional = 0
    for n in nodes:
        for c in (n.get("choices") or []):
            total += 1
            if c.get("when"):
                conditional += 1
    with_choices = sum(1 for n in nodes if (n.get("choices") or []))
    widest = max(nodes, key=lambda n: len(n.get("choices") or []))
    return {
        "choices": total,
        "choices_conditional": conditional,
        "nodes_with_choices": with_choices,
        "nodes_without_choices": len(nodes) - with_choices,
        "widest_node": f"{widest['id']}({len(widest.get('choices') or [])})",
    }


def declared_but_unwritten(spec: dict, nodes: list[dict]) -> list[str]:
    """声明了好感度、但没有任何选项 `add` 过的角色——「声明域 > 状态域」。"""
    written: set[str] = set()
    for n in nodes:
        for c in (n.get("choices") or []):
            written |= set(((c.get("effects") or {}).get("add") or {}))
    return sorted({c["id"] for c in spec["characters"]} - written)


def invariants(spec: dict, nodes: list[dict]) -> list[str]:
    """整数不变量：残差恒为 0。返回违规清单（空即通过）。"""
    bad: list[str] = []
    ids = {n["id"] for n in nodes}
    for n in nodes:
        for c in (n.get("choices") or []):
            if c["goto"] not in ids:
                bad.append(f"{c['id']} 的 goto 指向不存在的节点 {c['goto']}")
    for b in spec["beats"]:
        if not (TENSION_LO <= b["tension"] <= TENSION_HI):
            bad.append(f"beat {b['id']} 的 tension 越界 {b['tension']}")
    for c in spec["characters"]:
        a = c["affinity"]
        if not (AFF_LO <= a["init"] <= AFF_HI):
            bad.append(f"角色 {c['id']} 的 init 越界 {a['init']}")
    for f in spec["world"]["factions"]:
        for peer, v in f["stance"].items():
            if v not in (-1, 0, 1):
                bad.append(f"派系 {f['id']} 对 {peer} 的立场越界 {v}")
    return bad


def main() -> int:
    spec = load_spec()
    nodes = spec["dialogue"]

    world = count_world(spec["world"])
    chars = count_characters(spec["characters"])
    events = count_events(spec)
    choices = count_choices(nodes)

    print("构成   计数项")
    for k, v in world.items():
        print(f"世界   {k:<24} {v}")
    for k, v in chars.items():
        print(f"角色   {k:<24} {v}")
    for k, v in events.items():
        print(f"事件   {k:<24} {v}")
    for k, v in choices.items():
        print(f"选择   {k:<24} {v}")

    # 与 meta.scale 对账：这是四个构成与「声明规模」之间的唯一接口。
    scale = spec["meta"]["scale"]
    actual = {
        "scenes": events["scenes"],
        "characters": chars["characters"],
        "dialogue_nodes": events["dialogue_nodes"],
        "choices": choices["choices"],
        "flags": len(spec["state"]["flags"]),
        "affinity_vars": len(spec["state"]["vars"]),
        "items": len(spec["state"]["items"]),
        "factions": world["factions"],
        "endings": len(spec["endings"]),
    }
    print(f"meta.scale 对账：{'一致' if actual == scale else '不一致'} ({actual})")

    bad = invariants(spec, nodes)
    for b in bad:
        print(f"FAIL {b}")
    if bad:
        return 1

    unwritten = declared_but_unwritten(spec, nodes)
    print(f"声明了好感度但无选项写入的角色 {len(unwritten)} 个：{unwritten}")
    print("OK na_01_world_scale：四个构成清点完成，整数不变量残差 0")
    return 0


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

构成   计数项
世界   factions                 4
世界   stance_cells             16
世界   locations                14
世界   locations_locked         7
世界   lore                     6
世界   rules                    4
角色   characters               6
角色   goals                    12
角色   fears                    12
角色   secrets                  6
角色   arc_stages               18
角色   arc_beats                18
角色   thresholds               18
事件   acts                     3
事件   beats                    16
事件   scenes                   14
事件   edges                    16
事件   edges_unconditional      11
事件   edges_conditional        5
事件   dialogue_nodes           48
事件   ending_nodes             5
选择   choices                  115
选择   choices_conditional      34
选择   nodes_with_choices       43
选择   nodes_without_choices    5
选择   widest_node              d_dq_2(5)
meta.scale 对账：一致 ({'scenes': 14, 'characters': 6, 'dialogue_nodes': 48, 'choices': 115, 'flags': 18, 'affinity_vars': 4, 'items': 9, 'factions': 4, 'endings': 5})
声明了好感度但无选项写入的角色 2 个：['hai', 'lin']
OK na_01_world_scale：四个构成清点完成，整数不变量残差 0