1.2 规格驱动的对话状态机

if node == "d_pier_1":
    if flags["knows_yan_missing"]: show("问他灯塔为什么没亮")
    show("塞给他一枚铜板")

// file: core/src/inkwell/ne_01_2_machine.ts
// tier: P
// verify: node --test 'core/test/ne_01_2_machine.test.ts'
// 规格驱动的对话状态机：引擎里没有一条硬编码剧情，
// 全部由 spec 的 dialogue / state / endings 三段驱动。
// 只 import 既有 engine.ts 的公共内核（initState / applyChoice / condOk / canonical / digest），
// 绝不修改它——它是卷一交付的三处消费同源基准。

import { condOk, applyChoice, initState, canonical, digest, nodeById } from "./engine.ts";
import type { Spec, State, Choice, Ending } from "./engine.ts";

/** 当前节点上可用的选项：规格里声明、且 when 条件成立。可用性由状态决定，不是硬编码。 */
export function availableChoices(spec: Spec, s: State): Choice[] {
  return (nodeById(spec, s.node).choices ?? []).filter((c) => condOk(c.when, s));
}

/** 转移：纯函数，返回新状态。事件就是一次选项点击（choice id）。 */
export function advance(spec: Spec, s: State, choiceId: string): State {
  return applyChoice(spec, s, choiceId);
}

/** 结局判定：读 spec.endings，返回第一条条件成立的结局。规格驱动，非硬编码。 */
export function resolveEnding(spec: Spec, s: State): Ending | null {
  for (const e of spec.endings) if (condOk(e.when, s)) return e;
  return null;
}

/** 确定性策略：总是选第一个可用选项，走到终局节点。返回选择序列、终局状态与结局名。 */
export function runGreedy(spec: Spec): { choices: string[]; state: State; endingName: string } {
  let s = initState(spec);
  const choices: string[] = [];
  for (let i = 0; i < 200; i += 1) {
    const cur = nodeById(spec, s.node);
    if (cur.ending) break;
    const opts = availableChoices(spec, s);
    if (opts.length === 0) break;
    choices.push(opts[0].id);
    s = advance(spec, s, opts[0].id);
  }
  return { choices, state: s, endingName: nodeById(spec, s.node).ending ?? "" };
}

export { canonical, digest };

// file: core/test/ne_01_2_machine.test.ts
// tier: P
// verify: node --test 'core/test/ne_01_2_machine.test.ts'
// 规格驱动的对话状态机：验证引擎行为完全由 spec 驱动，引擎里没有硬编码剧情。

import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";

import { initState, digest, canonical } from "../src/inkwell/engine.ts";
import type { Spec, State } from "../src/inkwell/engine.ts";
import { availableChoices, advance, resolveEnding, runGreedy } from "../src/inkwell/ne_01_2_machine.ts";

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, "../..");
const spec = JSON.parse(readFileSync(join(ROOT, "config/story_spec.json"), "utf8")) as Spec;

test("可用选项由状态决定：同一节点 d_tavern_1，flag 不同则可选数不同", () => {
  const off = initState(spec);
  off.node = "d_tavern_1";
  const on: State = { ...off, flags: { ...off.flags, knows_yan_missing: 1 } };
  assert.equal(availableChoices(spec, off).length, 2);
  assert.equal(availableChoices(spec, on).length, 3);
});

test("转移是纯函数：入参状态不被改动", () => {
  const s0 = initState(spec);
  const before = canonical(s0);
  advance(spec, s0, "c_pier_1a");
  assert.equal(canonical(s0), before);
});

test("贪心走完一条路径：25 个事件、终局节点 e_lit、结局 灯守、摘要 4162796975", () => {
  const r = runGreedy(spec);
  assert.equal(r.choices.length, 25);
  assert.equal(r.state.node, "e_lit");
  assert.equal(r.endingName, "灯守");
  assert.equal(digest(r.state), 4162796975);
});

test("结局判定读 spec.endings：终局状态满足 e_lit 的 when", () => {
  const r = runGreedy(spec);
  const e = resolveEnding(spec, r.state);
  assert.ok(e, "终局状态应命中至少一条结局条件");
  assert.equal(e.id, "e_lit");
  assert.equal(e.name, "灯守");
});

✔ 可用选项由状态决定：同一节点 d_tavern_1，flag 不同则可选数不同 (0.607375ms)
✔ 转移是纯函数：入参状态不被改动 (0.227209ms)
✔ 贪心走完一条路径：25 个事件、终局节点 e_lit、结局 灯守、摘要 4162796975 (0.406917ms)
✔ 结局判定读 spec.endings：终局状态满足 e_lit 的 when (0.167833ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 302.159875