xsl/SoundGame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(playbook): 26 号交互手册首批落地——storyline/escape/simon 全面重构 + 引擎六模块

Browse Source 
按 docs/design/26-audio-interaction-playbook.md 重构三款游戏（对白重写 + 双性别语音重生成 580 文件）。

引擎层（web/engine/，其余 12 款游戏零改动）：
- floor.js 发言权管理器：SPEAKING/YOUR_TURN/BUSY/ACTION 四态、交接提示音、
  等待声（220/330Hz 嘟-嘟，20s 后放缓）、跨链音乐压低（audio.js holdDuck）
- receipts.js 输入回执三件套（ok/invalid/busy，100ms 内，原则 4）
- confusion.js 迷茫检测（乱点/无效/静默信号 → 三级接管，§4.5）
- hints.js 等待点 + 三档提示（full→short→提示音，30s 台账跨点去重，原则 9）
- novice.js 手势解锁阶梯（up/down/doubletap 跨局持久，§4.3）
- pipeline.js 输入管道（回执收口、防连点 400ms、双击折算、explainOnce）

游戏层：
- storyline R3：开场 71.7s 规则念白 → 3 秒内动手；双击=重播（反模式5）废除；
  抉择点三档提示+主动重听；断点存档复述（§4.12）
- escape R3：单击=检查+使用合并（双击用法废除）；长按=我在哪（四向玩法裁定）；
  撞墙归因每方向一次（原则 7）；迷茫 L2 缩小/L3 演示；坐标存档续玩
- simon R3：新手三音色，按实力渐进解锁（+up/down/dt）；失败表替代机会账
  （归因 2s 内→免费重听→放慢→结算，原则 15）；播放期手势=busy 回执

测试：三款 playtest 重写（含 §6.2 乱点机器人：无声操作/被动重复/打断失败全 0，
首操作 ~2s）；guide.test 改为 Guide 层单测+rhythm/space 段。全部通过
（38+33+22+72+19+35 断言）。设计单见 docs/design/26-apply-*.md。
This commit is contained in:
xsl
2026-10-01 08:11:12 +08:00
parent d15a9b9635
commit ee9d7efe57
1183 changed files with 3945 additions and 4588 deletions
Download Patch File Download Diff File Expand all files Collapse all files
web/storyline/test/playtest.mjs
+324 -387
View File
@@ -1,14 +1,16 @@
/**
* 《声命线》无头试玩仿真测试（docs/design/13-playtest-criteria.md §1 + §7）。
* 《声命线》R3 无头试玩仿真测试（26 号文档 playbook 重构版）。
*
* 方案：
* - mock 浏览器环境：window/localStorage/navigator/fetch/AudioContext
* （decodeAudioData 返回固定 duration 的假 buffer；fetch 直接读真实资产目录，
* 缺失资产走引擎 console.error 静默路径）；
* - 使用**真实** engine/audio.js + settings.js（voice 链靠引擎 endTimer +
* onComplete 推进，虚拟时钟驱动，不真实等待）；
* - 手势直接注入 game.onGesture（与 attachGestures 回调同路径）；
* - 虚拟时钟：patch setTimeout/clearTimeout/performance.now。
* 覆盖：
* - §4.10 首 3 分钟脚本：3 秒内第一次操作、10 秒内第一次成功（ok 回执）；
* - §4.1 发言权：链间不掉回「轮到你」、tap=跳句、滑动=打断并执行；
* - §4.2 回执 + 防连点（400ms 内第二下只给 busy）；
* - §4.3 手势阶梯：up/down/doubletap 未解锁时的处理与首次解释；
* - §4.4 三档提示：full → short → 提示音；主动重听 = 「再说一遍：」+ 完整句；
* - §4.5 迷茫接管三级；
* - §4.12 断点复述；
* - §6.2 乱点机器人：无声操作 = 0、打断失败 = 0、被动原句重复 = 0、首成功 ≤ 10s；
* - 资产引用校验（新台词全部落地后零缺失）。
*
* 运行：tools/node/bin/node web/storyline/test/playtest.mjs
*/
@@ -29,18 +31,17 @@ function assert(cond, msg) {
else { failures.push(msg); realLog(` ✗ ${msg}`); }
}
// console 捕获（引擎/游戏的 warn/error 进日志，测试输出用 realLog）
const consoleErrs = [];
const consoleWarns = [];
console.error = (...a) => { consoleErrs.push(a.join(' ')); };
console.warn = (...a) => { consoleWarns.push(a.join(' ')); };
console.log = () => {}; // 游戏逐手势 console.log，静默
console.log = () => {};
// ---------------------------------------------------------------- 虚拟时钟
let now = 0; // 虚拟毫秒
let now = 0;
let timerSeq = 1;
const timers = new Map(); // id -> { fireAt, cb, args }
const timers = new Map();
const realSetImmediate = setImmediate;
globalThis.setTimeout = (cb, ms = 0, ...args) => {
@@ -53,17 +54,12 @@ Object.defineProperty(globalThis, 'performance', {
value: { now: () => now }, configurable: true,
});
/** 排空微任务（fetch/decode 的 promise 链）。 */
async function flush(rounds = 8) {
for (let i = 0; i < rounds; i++) await new Promise((r) => realSetImmediate(r));
}
/**
* 推进虚拟时钟：逐个触发到期定时器，直到没有待触发定时器（= 游戏在等手势）
* 或 cond() 满足。返回 'cond' | 'idle'。
*/
async function advance(cond = null) {
for (let n = 0; n < 50000; n++) {
for (let n = 0; n < 200000; n++) {
await flush(2);
if (cond && cond()) return 'cond';
let nextId = -1; let nextAt = Infinity;
@@ -77,6 +73,7 @@ async function advance(cond = null) {
throw new Error('虚拟时钟定时器超上限（疑似死循环）');
}
const idle = () => advance(null);
const tick = (ms) => { now += ms; };
// ---------------------------------------------------------------- 浏览器 mock
@@ -86,11 +83,8 @@ globalThis.window = {
if (!winListeners.has(type)) winListeners.set(type, []);
winListeners.get(type).push(fn);
},
AudioContext: null, // 下方赋值
AudioContext: null,
};
function fireWindowEvent(type) {
for (const fn of winListeners.get(type) || []) fn();
}
const storageData = new Map();
globalThis.localStorage = {
@@ -101,8 +95,6 @@ globalThis.localStorage = {
const vibrateLog = [];
Object.defineProperty(globalThis, 'navigator', {
// maxTouchPoints: 1 —— 手机 persona：inputMode() 判 touch，语音走触屏措辞主资产
// （键盘变体路由的桌面路径由 harness/engine-input.test.mjs K9 专测）
value: { maxTouchPoints: 1, vibrate: (...a) => { vibrateLog.push(a[0]); return true; } }, configurable: true,
});
@@ -117,11 +109,9 @@ class MockGainNode {
connect() {}
disconnect() {}
}
function fakeBuffer() {
function fakeBuffer(dur = 2.0) {
return {
duration: 2.0, // 固定句长 2s（虚拟时钟推进语音链）
numberOfChannels: 1,
sampleRate: 44100,
duration: dur, numberOfChannels: 1, sampleRate: 44100,
getChannelData: () => new Float32Array(16),
};
}
@@ -138,7 +128,6 @@ class MockAudioContext {
return { buffer: null, loop: false, connect() {}, start() {}, stop() {} };
}
createScriptProcessor() { return { connect() {}, disconnect() {}, onaudioprocess: null }; }
// 向导层 earcon 运行时合成所需（guide=standard/full 时 guide.state/nudge 会创建）
createOscillator() {
return { type: 'sine', frequency: new MockParam(440), connect() {}, start() {}, stop() {} };
}
@@ -147,7 +136,6 @@ class MockAudioContext {
}
globalThis.window.AudioContext = MockAudioContext;
// fetch：读真实资产目录；blockedAssets 中的片段强制 404（看门狗测试用）
const requestedUrls = [];
const blockedAssets = new Set();
globalThis.fetch = async (u) => {
@@ -155,6 +143,11 @@ globalThis.fetch = async (u) => {
requestedUrls.push(s);
const blocked = [...blockedAssets].some((b) => s.includes(b));
const p = path.join(GAME_DIR, decodeURIComponent(s));
// 缺失 voice 资产按可用处理（decode 是 mock，统一 2s 句长）——流程测试与
// TTS 资产生成解耦，资产品质由文末「资产引用校验」单独把关。
if (s.includes('/voice/') && !blocked) {
return { ok: true, status: 200, arrayBuffer: async () => new ArrayBuffer(0) };
}
if (blocked || !fs.existsSync(p)) {
return { ok: false, status: 404, arrayBuffer: async () => new ArrayBuffer(0) };
}
@@ -165,409 +158,360 @@ globalThis.fetch = async (u) => {
};
};
// ---------------------------------------------------------------- 加载引擎与游戏
// ---------------------------------------------------------------- 加载引擎与游戏（含输入管道）
const { WebAudioEngine } = await import('../../engine/audio.js');
const { settings } = await import('../../engine/settings.js');
const { makeInputPipeline } = await import('../../engine/pipeline.js');
const { StorylineGame } = await import('../game.js');
// 向导层关闭：回归测试只验证纯游戏逻辑（guide='full' 的行为由 harness/guide.test.mjs 覆盖）
settings.set({ guide: 'off', voice: 'female', speed: 1.0, bgm: 1.0 });
let gestureCount = 0;
function makeRig() {
const audio = new WebAudioEngine('audio/');
const playLog = [];
const origPlay = audio.play.bind(audio);
audio.play = (id, opts) => { playLog.push({ id, t: now }); return origPlay(id, opts); };
const game = new StorylineGame(audio, {});
return { audio, playLog, game };
// 回执记录（§6.2 无声操作指标的探针）
const receiptLog = [];
const origReceipt = game.receipts.play.bind(game.receipts);
game.receipts.play = (kind) => { receiptLog.push({ kind, t: now }); return origReceipt(kind); };
// 管道（与 index.html 同构）；bed 关掉防周期定时器不排水
game.floor.bedEnabled = false;
const pipe = makeInputPipeline({
floor: game.floor,
confusion: game.confusion,
receipts: game.receipts,
invalidHints: game.invalidHints,
game,
ladder: game.ladder,
});
return { audio, playLog, receiptLog, game, pipe };
}
async function g(game, gesture) {
gestureCount++;
game.onGesture(gesture);
async function g(rig, gesture) {
rig.pipe(gesture);
await flush();
if (process.env.TRACE) {
realLog(` [gesture ${gesture}] node=${game.nodeId} mode=${game.mode} playing=${game.voicePlaying} cur=${game.currentVoiceId} armed=${game.choiceArmed}`);
}
}
const voicePlays = (playLog, id) => playLog.filter((e) => e.id === id).length;
const urlHits = (frag) => requestedUrls.filter((u) => u.includes(frag)).length;
// ================================================================ 主路径试玩
realLog('== 主路径试玩（关键路径 + 边界断言）==');
{
const { audio, playLog, game } = makeRig();
// §7.1 解锁前 play 为 no-op
audio.play('voice/n00_intro');
await flush();
assert(audio._voice === null && consoleWarns.some((w) => w.includes('尚未解锁')),
'启动遮罩点按前无音频播放（play 为 no-op）');
await audio.unlock();
// 1. start() → BGM + n00 旁白
game.start();
await flush();
assert(playLog.some((e) => e.id === 'bgm/dark_drone'), '开局播放 bgm/dark_drone');
assert(game.nodeId === 'n00' && game.voicePlaying && game.currentVoiceId === 'voice/n00_intro',
'n00 旁白开始（voice 层有播放记录）');
// 长按快进（引擎内置）：临时 1.7× 不变调，松手恢复
fireWindowEvent('soundgame:longpress');
assert(audio._voice && audio._voice.st.tempo === 1.7, '长按 → 旁白临时 1.7 倍速');
fireWindowEvent('soundgame:longpressend');
assert(audio._voice && audio._voice.st.tempo === 1.0, '松开 → 恢复 settings.speed');
// ② 单击跳过本句：n00_intro → skip_hint（链继续，不断）
await g(game, 'tap');
assert(game.voicePlaying && game.currentVoiceId === 'voice/skip_hint',
'voice 播放中单击 = 跳过本句（skipVoice 续链到 skip_hint）');
await idle();
assert(!game.voicePlaying && game.nodeId === 'n00', 'n00 链播完，等待单击继续');
assert(voicePlays(playLog, 'voice/skip_hint') === 1, '③ 开场 skip_hint 提示播了一次');
// 切男声：下一句起用 male 目录
settings.set({ voice: 'male' });
await g(game, 'tap'); // → n01
await flush();
assert(urlHits('audio/voice/male/n01_wake.') > 0, 'settings.voice=male 后旁白走 male 目录');
// 双击重听当前节点
const beforeReplay = voicePlays(playLog, 'voice/n01_wake');
await g(game, 'doubletap');
assert(game.currentVoiceId === 'voice/n01_wake'
&& voicePlays(playLog, 'voice/n01_wake') === beforeReplay + 1,
'语音播放中双击 = 重听当前节点（同一 voice id 重播）');
// 菜单：BGM 切 menu pad，返回剧情节点不丢、BGM 淡回
await g(game, 'down');
assert(game.mode === 'MENU', '下滑呼出菜单');
await flush();
assert(audio._bgm && audio._bgm.id === 'bgm/menu', '② 进菜单 BGM 切 bgm/menu');
await idle(); // voice/menu 播完
await g(game, 'tap'); // 关菜单
assert(game.mode === 'STORY' && game.nodeId === 'n01', '关菜单返回剧情，节点不丢（不重头）');
await flush();
assert(audio._bgm && audio._bgm.id === 'bgm/dark_drone', '② 关菜单 BGM 淡回 dark_drone');
await idle(); // 重播 n01 播完
// 上滑：帮助 + 进度，随后自动重播当前节点
await g(game, 'up');
assert(game.currentVoiceId === 'voice/help', '上滑播放操作说明');
await idle();
assert(voicePlays(playLog, 'voice/status1') === 1, '帮助后播当前进度（第一幕 status1）');
// settings.bgm = 0 → 立即静默；调回 → 补播最后状态 BGM
settings.set({ bgm: 0 });
await flush();
assert(audio._bgm === null, 'settings.bgm=0 时无 bgm 层播放');
settings.set({ bgm: 1 });
await flush();
assert(audio._bgm && audio._bgm.id === 'bgm/dark_drone', 'bgm 调回后自动补播最后状态 BGM');
// → n02（抉择点）。n02_linwan 是角色音（林晚）：male 目录无，平铺回退命中
settings.set({ speed: 1.7 });
requestedUrls.length = 0;
await g(game, 'tap');
await flush();
assert(game.nodeId === 'n02', '进入 n02 抉择节点');
assert(audio._voice && audio._voice.st.tempo === 1.7, 'settings.speed=1.7 下一句起生效');
assert(urlHits('audio/voice/male/n02_linwan.') > 0 && urlHits('audio/voice/n02_linwan.ogg') > 0,
'④ 角色音 n02_linwan 走平铺目录回退（不随性别设置变化）');
settings.set({ speed: 1.0 });
// 抉择提示 p1 播放中：单击不可跳；滑动缓存 pendingChoice
await advance(() => game.currentVoiceId === 'voice/p1');
assert(game.promptPlaying, '抉择提示 p1 播放中（promptPlaying=true）');
await g(game, 'tap');
assert(game.currentVoiceId === 'voice/p1', '① 抉择提示播放中单击不可跳');
await g(game, 'right');
assert(game.pendingChoice === 'right', '提示音播放中右滑缓存 pendingChoice');
await idle();
assert(game.nodeId === 'n04', '链尾 pendingChoice 生效 → n04');
assert(!game.companion && !game.knowTrap && !game.betrayed, '剧情标记初始为 false');
// n04 → n05 → n06 → n07（无语音时单击维持原义：继续剧情）
settings.set({ voice: 'female' }); // 切回女声，验证女性设置下角色音同样平铺
for (const next of ['n05', 'n06', 'n07']) {
await idle();
await g(game, 'tap');
assert(game.nodeId === next, `单击继续剧情 → ${next}`);
}
await idle();
assert(game.choiceArmed, 'n07 提示播完 choiceArmed=true（等待抉择）');
await g(game, 'right'); // 装死 → n09
assert(game.nodeId === 'n09' && game.knowTrap === true, 'n09 右滑 → knowTrap === true');
requestedUrls.length = 0;
await idle();
await g(game, 'tap'); // → n10
await idle();
await g(game, 'left'); // 闻声寻去 → n11
assert(game.nodeId === 'n11', 'n10 左滑 → n11');
await idle();
await g(game, 'left'); // 带上小满 → n12
assert(game.nodeId === 'n12' && game.companion === true, 'n11 左滑 → companion === true');
await idle();
await g(game, 'tap'); // → n15 断桥
await idle();
await g(game, 'left'); // 涵洞（带小满 → 虚拟节点解析 n16b）
assert(game.nodeId === 'n16b', '虚拟节点 resolve：带小满时 v_culvert → n16b');
await idle();
await g(game, 'tap'); // → n18
await idle();
assert(urlHits('audio/voice/n18_dog.ogg') > 0 || urlHits('audio/voice/female/n18_dog.') > 0,
'n18 旁白正常加载');
await g(game, 'left'); // 交出坐标 → n19
assert(game.nodeId === 'n19' && game.betrayed === true, 'n18 左滑 → betrayed === true');
await idle();
await g(game, 'tap'); // → n20
await idle();
await g(game, 'left'); // 赎罪 → n21
assert(game.nodeId === 'n21', 'n20 左滑 → n21');
await idle();
await g(game, 'tap'); // → e2 结局：代价
assert(game.nodeId === 'e2', '到达结局节点 e2（4 结局之一）');
await idle();
assert(voicePlays(playLog, 'voice/e2_price') === 1, '结局语音 e2_price 播出');
assert(game.awaitingRestart === true, '结局链播完进入结算态（awaitingRestart）');
assert(audio._bgm && audio._bgm.id === 'bgm/dark_drone',
'② 结局结算保持 dark_drone 不切（10 号文档 §2）');
// 结算态单击重开回 n00
await g(game, 'tap');
assert(game.nodeId === 'n00' && game.mode === 'STORY'
&& !game.companion && !game.knowTrap && !game.betrayed,
'结算态单击重开回 n00，剧情标记重置');
await idle();
assert(voicePlays(playLog, 'voice/skip_hint') === 1, '③ 重开后 skip_hint 不重播（每局一次）');
assert(gestureCount <= 40, `关键路径手势预算 ≤40（实际 ${gestureCount}）`);
// 手势时刻记录（打断失败指标用）
function makeGestureProbe(rig) {
const origPipe = rig.pipe;
const gestures = [];
rig.pipe = (gg, info) => { gestures.push({ g: gg, t: now }); return origPipe(gg, info); };
return gestures;
}
// ================================================================ 看门狗路径
// ================================================================ 主路径：首 3 分钟脚本（§4.10）
realLog('== 看门狗路径（屏蔽 voice/n05_signal）==');
realLog('== 首 3 分钟脚本（§4.10：3 秒内动手、10 秒内首成功）==');
{
settings.set({ voice: 'female', speed: 1.0, bgm: 1.0 });
blockedAssets.add('n05_signal');
const errBefore = consoleErrs.length;
const { audio, game } = makeRig();
const rig = makeRig();
const { audio, playLog, receiptLog, game, pipe } = rig;
try {
await audio.unlock();
game.start();
await idle();
await g(game, 'tap'); // n01
await idle();
await g(game, 'tap'); // n02
await idle(); // n02_linwan + p1 播完
await g(game, 'right'); // → n04
await idle();
await g(game, 'tap'); // → n05（第一句 n05_signal 被屏蔽）
await idle(); // 看门狗 30s 超时续链 → n05_bcast 播完
assert(consoleErrs.slice(errBefore).some((e) => e.includes('n05_signal')),
'屏蔽资产仅 console.error，不抛异常');
assert(consoleWarns.some((w) => w.includes('看门狗')), '语音看门狗超时自动续链');
assert(game.nodeId === 'n05' && !game.voicePlaying, '缺失 voice 不卡死：n05 链走完');
await g(game, 'tap'); // n06
await idle();
await g(game, 'tap'); // n07（非抉择点 n06 之后继续剧情）
await idle();
await g(game, 'right'); // n07 装死 → n09
await idle();
await g(game, 'tap'); // n10
await idle();
await g(game, 'right'); // n14
await idle();
await g(game, 'tap'); // n15
await idle();
await g(game, 'right'); // n17（无小满 → v_cable → n17）
assert(game.nodeId === 'n17', '虚拟节点 resolve：无小满时 v_cable → n17');
await idle();
await g(game, 'tap'); // n18
await idle();
await g(game, 'right'); // n22
await idle();
await g(game, 'tap'); // n23
await idle();
await g(game, 'left'); // n23 开闸 → n24
await idle();
await g(game, 'tap'); // n24 播完单击 → e4
assert(game.nodeId === 'e4', '屏蔽资产后仍可推进到结局 e4');
await idle();
assert(game.awaitingRestart === true, '看门狗路径到达结算态');
blockedAssets.clear();
await flush();
assert(voicePlays(playLog, 'voice/sys_first_tap') === 1 && game.floor.speaking,
'0~3 秒：开场第一句 = 「点一下屏幕。」（第一句就让动手）');
// 指令句 critical：抢拍单击 = busy 回执（不打断唯一一次教学）
await pipe('tap'); await flush();
assert(receiptLog.some((r) => r.kind === 'busy'), '指令播放中单击 = busy 回执（关键句不可打断）');
await advance(() => game.floor.state === 'YOUR_TURN'); // 指令句播完交话轮
await pipe('tap'); await flush(); // 第一次有效操作
assert(receiptLog.some((r) => r.kind === 'ok'),
'第一次单击 100ms 内得到 ok 回执（第一次成功）');
assert(game.floor.speaking && voicePlays(playLog, 'voice/n00_a') === 1,
'单击后播 n00_a 旁白');
// 链间不掉回「轮到你」听感：n00_a → sys_turn_teach 是一条链（holdDuck 期间）
await advance(() => playLog.some((e) => e.id === 'voice/sys_turn_teach'));
assert(game.floor.speaking, '链第二句 sys_turn_teach 播出（整条链都算 SPEAKING）');
assert(audio._duckHolds > 0, '语音链期间持有音乐压低（holdDuck，§4.1）');
// 单击跳句：tap 跳过 sys_turn_teach → 链尾（onDone → yieldTurn）
await pipe('tap'); await flush();
assert(game.floor.state === 'YOUR_TURN', '单击跳句后整条链走完，交出话轮（YOUR_TURN）');
// 防连点：tap「继续」后 400ms 内的第二下只给 busy（不连跳两句）
await advance(() => game.floor.state === 'YOUR_TURN'); // 教学链完（skip 已同步交话轮）
tick(500); // 跨过 skip 那一下的 400ms 防连点窗口
const busyBefore = receiptLog.filter((r) => r.kind === 'busy').length;
const nodeBefore = game.nodeId;
await pipe('tap'); await flush(); // → n00 节点新链（一次「继续」）
await pipe('tap'); await flush(); // 虚拟时钟未推进 = 400ms 内 → busy
const busyAfter = receiptLog.filter((r) => r.kind === 'busy').length;
assert(busyAfter === busyBefore + 1,
'防连点：tap「继续」后 400ms 内的第二下只给 busy 回执');
assert(game.nodeId !== nodeBefore || game.floor.speaking, '第一下 tap 已生效（推进/新链）');
} finally { game.stop(); }
}
// ================================================================ live round2 N1
// （docs/design/13-playtest-criteria.md §16：真实在播的长语音不被 30s 看门狗掐断）
// ================================================================ 抉择点：三档提示 + 主动重听 + 打断语义
realLog('== live round2 N1：长语音看门狗续约不掐（§16）==');
realLog('== 抉择点（§4.4 三档 / 原则 9 重听 / §4.1 滑动打断）==');
{
settings.set({ guide: 'off', voice: 'female', speed: 1.0, bgm: 1.0 });
const { audio, playLog, game } = makeRig();
const rig = makeRig();
const { audio, playLog, receiptLog, game, pipe } = rig;
await audio.unlock();
// 预植 40s 长语音缓存（模拟真实 intro 71.7s 超 30s 阈值的情形；虚拟时钟不真实等待）
// 缓存键格式（P1 起）： <inputMode>|<gender>|<id>（见 engine/audio.js _load）
audio._cache.set('main|female|voice/n00_intro', Promise.resolve({
duration: 40.0, numberOfChannels: 1, sampleRate: 44100,
getChannelData: () => new Float32Array(16),
}));
const warnBefore = consoleWarns.length;
storageData.clear();
game.start();
await flush();
await pipe('tap'); await flush(); // → n00_a 链
await advance(() => game.floor.state === 'YOUR_TURN'); // 教学链完
await pipe('tap'); await flush(); // → n00_b 链
await advance(() => game.floor.state === 'YOUR_TURN');
await pipe('tap'); await flush(); // → n00 节点（n00_b + skip_hint）
await advance(() => game.floor.state === 'YOUR_TURN');
await pipe('tap'); await flush(); // → n01
await advance(() => game.floor.state === 'YOUR_TURN');
await pipe('tap'); await flush(); // → n02（抉择：n02_linwan + p1）
assert(game.nodeId === 'n02', '推进到 n02 抉择节点');
// 旁白播放中滑动 = 打断并执行 → 跳去选项句（不当场盲选）
assert(game.chainKind === 'story' && game.floor.speaking, 'n02 旁白链在播');
await pipe('left'); await flush();
assert(game.chainKind === 'prompt', '旁白中左滑：跳去选项（chainKind=prompt，不当场盲选）');
await advance(() => game.floor.state === 'YOUR_TURN');
const wp = game.floor.waitPoint;
assert(wp && wp.conf.id === 'choice', '选项句播完交出抉择等待点');
// 抉择点空点 = 主动再听选项：「再说一遍：」+ 完整句（原则 9）
await pipe('tap'); await flush();
assert(voicePlays(playLog, 'voice/sys_say_again') === 1 && voicePlays(playLog, 'voice/p1') >= 1,
'抉择点单击 = 「再说一遍：」+ p1 完整句');
await advance(() => game.floor.state === 'YOUR_TURN');
// 左滑 → 抉择生效（剧情标记）
await pipe('left'); await flush();
assert(game.nodeId === 'n03', '左滑抉择 → n03');
assert(game.ladder.stage() >= 1, '第一次抉择完成 → 手势阶梯阶段 1（上滑解锁）');
game.stop();
}
// ================================================================ 三档提示 + 迷茫接管（§4.4 / §4.5）
realLog('== 三档提示与迷茫接管 ==');
{
const rig = makeRig();
const { audio, playLog, game, pipe } = rig;
await audio.unlock();
storageData.clear();
game.start();
await flush();
await advance(() => game.floor.state === 'YOUR_TURN'); // 指令播完
await pipe('tap'); await flush(); // → n00_a + turn_teach
await advance(() => game.floor.state === 'YOUR_TURN'); // 教学链完（continue 等待点挂上）
// 静默梯度：18s full → 40s short → 更久只给提示音
const t0 = now;
await advance(() => voicePlays(playLog, 'voice/sys_hint_continue_full') >= 1);
assert(now - t0 === 18000, `剧情类静默 18s 给 full 档（实际 ${now - t0}ms）`);
await advance(() => voicePlays(playLog, 'voice/sys_hint_continue_short') >= 1);
assert(now - t0 === 40000, `持续静默 40s 降为 short 档（实际 ${now - t0}ms）`);
assert(voicePlays(playLog, 'voice/sys_hint_continue_full') === 1, '同一信息不原样重复（full 只播一次）');
game.stop();
}
realLog('== 迷茫接管（乱点信号：10s 内 3 次无效 → L1 短句 → L2 缩小）==');
{
const rig = makeRig();
const { audio, playLog, game, pipe } = rig;
await audio.unlock();
storageData.clear();
game.start();
await flush();
assert(game.currentVoiceId === 'voice/n00_intro', 'N1：40s 长 intro 开播');
// 越过 30s 看门狗阈值：voice 真在播 → 不掐、不续链、无告警
await advance(() => now - t0 >= 30000);
assert(game.currentVoiceId === 'voice/n00_intro' && audio.isVoicePlaying()
&& game.nodeId === 'n00',
'N1：30s 看门狗触发时 voice 真在播 → 不续链（仍停在 intro）');
assert(!consoleWarns.slice(warnBefore).some((w) => w.includes('看门狗')),
'N1：在播长语音不触发看门狗告警');
// 自然播完才续链下一句（skip_hint 不再顶掉 intro 末句——冷启动末句被吃的根因）
await advance(() => game.currentVoiceId === 'voice/skip_hint');
assert(now - t0 >= 40000, `N1：intro 自然播完才续链 skip_hint（实际 ${now - t0}ms）`);
assert(voicePlays(playLog, 'voice/skip_hint') === 1, 'N1：skip_hint 在 intro 播完后播出');
await idle();
assert(!game.voicePlaying && game.nodeId === 'n00', 'N1：长链正常走完进入等待态');
await advance(() => game.floor.state === 'YOUR_TURN'); // 指令播完
await pipe('tap'); await flush();
await advance(() => game.floor.state === 'YOUR_TURN'); // continue 等待点
// 非抉择节点连滑 3 次（每次 invalid 回执 + 迷茫记账）
const shortBefore = voicePlays(playLog, 'voice/sys_hint_continue_short');
for (let i = 0; i < 3; i++) { await pipe('left'); await flush(); }
await advance(() => voicePlays(playLog, 'voice/sys_hint_continue_short') > shortBefore);
assert(game.confusion.level >= 1, '10s 内 3 次无效滑动 → 迷茫接管 L1（§4.5 连续无效权重 2）');
await advance(() => !game.floor.speaking && game.floor.state === 'YOUR_TURN');
// L2：过 15s 冷却后再乱点 → 只放行 tap（restricted）
const tL1 = now;
await advance(() => now - tL1 >= 16000); // 迷茫冷却期（§4.5：15s 内不再触发）
await advance(() => !game.floor.speaking && game.floor.state === 'YOUR_TURN');
for (let i = 0; i < 3; i++) { await pipe('right'); await flush(); }
await advance(() => game.confusion.level >= 2 || now - tL1 > 60000);
const wp = game.floor.waitPoint;
assert(game.confusion.level >= 2, '冷却后再乱点 → 接管升到 L2');
assert(wp && wp.restricted && !wp.allows('left') && wp.allows('tap'),
'接管 L2：等待点只放行 expected 手势（缩小选择）');
game.stop();
}
// ================================================================ live round1 修复断言
// （docs/design/13-playtest-criteria.md §10：结局双击重听 / 结局状态播报；
// §10 分支台词口径经 §16 N2 翻案——钢索路径恢复播 n18_dog）
// ================================================================ 手势阶梯（§4.3）
realLog('== live round1 修复断言（§10+§16：结局重听 / n18 两路径 / 结局状态）==');
realLog('== 手势阶梯：未解锁手势的回执与首次解释 ==');
{
settings.set({ guide: 'off', voice: 'female', speed: 1.0, bgm: 1.0 });
const { audio, playLog, game } = makeRig();
const rig = makeRig();
const { audio, playLog, receiptLog, game, pipe } = rig;
await audio.unlock();
storageData.clear();
game.start();
await idle(); // n00 链播完
await flush();
await advance(() => game.floor.state === 'YOUR_TURN'); // 开场指令播完
// 钢索路径推进到 n18：n01→n02(right→n04)→n05→n06→n07(right→n09)→n10(right→n14)→n15
await g(game, 'tap'); await idle(); // → n01
await g(game, 'tap'); await idle(); // → n02（抉择）
await g(game, 'right'); await idle(); // → n04
await g(game, 'tap'); await idle(); // → n05
await g(game, 'tap'); await idle(); // → n06
await g(game, 'tap'); await idle(); // → n07（抉择）
await g(game, 'right'); await idle(); // → n09
await g(game, 'tap'); await idle(); // → n10（抉择）
await g(game, 'right'); await idle(); // → n14
await g(game, 'tap'); await idle(); // → n15（抉择）
await g(game, 'right'); await idle(); // 钢索 → n17（无涵洞经历）
assert(game.nodeId === 'n17' && game.viaCulvert === false,
'n15 右滑 → 钢索 n17（viaCulvert === false）');
// 未解锁 up：invalid 回执 + 首次解释
await pipe('up'); await flush();
assert(receiptLog.some((r) => r.kind === 'invalid'), '未解锁上滑 → invalid 回执');
await advance(() => voicePlays(playLog, 'voice/inv_up_locked') >= 1);
assert(voicePlays(playLog, 'voice/inv_up_locked') === 1, '首次无效附一句解释（原则 7）');
const invCount = voicePlays(playLog, 'voice/inv_up_locked');
await advance(() => !game.floor.speaking);
await pipe('up'); await flush();
assert(voicePlays(playLog, 'voice/inv_up_locked') === invCount,
'第二次起只给回执，不再解释（原则 7）');
// round2 N2（§10 P2-2 矫枉过正翻案）：钢索路径恢复播 n18_dog 对峙戏 + p6
await g(game, 'tap'); await idle(); // → n18
assert(game.nodeId === 'n18' && voicePlays(playLog, 'voice/n18_dog') === 1
&& voicePlays(playLog, 'voice/p6') === 1,
'N2：钢索路径 n18 恢复播 n18_dog（对峙戏）+ 抉择提示 p6（known-issue：涵洞句轻微穿帮待 TTS 分支句）');
// 推进到结局 e2：n19→n20(left→n21)→e2
await g(game, 'left'); await idle(); // n18 交坐标 → n19
await g(game, 'tap'); await idle(); // → n20（抉择）
await g(game, 'left'); await idle(); // → n21
await g(game, 'tap'); await idle(); // → e2
assert(game.nodeId === 'e2' && game.awaitingRestart === true, '到达结局 e2 进入结算态');
// P2-1 结局双击重听：结算态双击 → 结局语音重播；重播中单击 = 跳句不重开
const e2before = voicePlays(playLog, 'voice/e2_price');
await g(game, 'doubletap');
assert(game.voicePlaying && game.currentVoiceId === 'voice/e2_price'
&& voicePlays(playLog, 'voice/e2_price') === e2before + 1,
'P2-1：结局结算态双击 = 重播结局语音');
assert(game.awaitingRestart === false, 'P2-1：结局重播期间离开结算态（单击回到跳句语义）');
await g(game, 'tap'); // 重播中单击 = 跳过本句
assert(game.nodeId === 'e2', 'P2-1：结局重播中单击跳过本句，不触发重开');
await idle();
assert(game.awaitingRestart === true && !game.voicePlaying, 'P2-1：结局重播链播完回到结算态');
// P3-2 结局后状态播报：help 后播当前结局语音（不再报 status3），播完回结算态
const e2again = voicePlays(playLog, 'voice/e2_price');
await g(game, 'up');
assert(game.currentVoiceId === 'voice/help', 'P3-2：结局后上滑先播 help');
await idle();
assert(voicePlays(playLog, 'voice/e2_price') === e2again + 1
&& voicePlays(playLog, 'voice/status3') === 0,
'P3-2：结局后状态播报 = 当前结局语音（不再报 status3）');
assert(game.awaitingRestart === true && !game.voicePlaying,
'P3-2：状态播完直接回结算态（不二次重播节点）');
// 未解锁 down / 双击折算
await advance(() => !game.floor.speaking);
await pipe('down'); await flush();
assert(receiptLog.filter((r) => r.kind === 'invalid').length >= 2, '未解锁下滑 → invalid 回执');
await advance(() => !game.floor.speaking);
const chainBefore = playLog.length;
await pipe('doubletap'); await flush(); // 折算为 tap → 「继续」
assert(receiptLog.some((r) => r.kind === 'ok' && r.t >= 0)
&& playLog.length > chainBefore, '未解锁双击按一次单击处理（继续剧情）');
game.stop();
}
// ================================================================ 静默兜底（standard 档）
// （docs/design/13-playtest-criteria.md §10：13s gd_continue / 30s gd_again / 手势重置）
// ================================================================ 断点复述（§4.12）
realLog('== 静默兜底（guide=standard，§10 P2-3）==');
realLog('== 断点复述 ==');
{
settings.set({ guide: 'standard', voice: 'female', speed: 1.0, bgm: 1.0 });
const { audio, playLog, game } = makeRig();
// 局一推进到 n05 后 stop() → 新 rig start() 应问「继续上次 / 从头开始」
const rig1 = makeRig();
await rig1.audio.unlock();
storageData.clear();
rig1.game.start();
await flush();
await rig1.pipe('tap'); await flush();
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
await rig1.pipe('tap'); await flush();
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
await rig1.pipe('tap'); await flush(); // → n00 节点
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
await rig1.pipe('tap'); await flush(); // → n01
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
await rig1.pipe('tap'); await flush(); // → n02
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
await rig1.pipe('right'); await flush(); // → n04
await advance(() => rig1.game.floor.state === 'YOUR_TURN');
rig1.game.stop(); // 退出自动存档（原则 16）
const rig2 = makeRig();
const { audio, playLog, game, pipe } = rig2;
await audio.unlock();
game.start();
await advance(() => !game.voicePlaying); // n00 链播完（精确停链尾，不越过看门狗）
assert(game.nodeId === 'n00' && !game.voicePlaying, 'standard：n00 链播完进入等待态');
const tArm = now;
await advance(() => voicePlays(playLog, 'voice/gd_continue') >= 1);
assert(now - tArm === 13000, `standard：13s 无操作播 gd_continue（实际 ${now - tArm}ms）`);
await advance(() => voicePlays(playLog, 'voice/gd_again') >= 1);
assert(now - tArm === 30000, `standard：30s 升级播 gd_again（实际 ${now - tArm}ms）`);
await idle(); // 两级用尽彻底静默（无更多定时器）
// 玩家手势后重置：新节点播完重新挂载，13s 再次提示
await g(game, 'tap'); // → n01
await advance(() => !game.voicePlaying);
assert(game.nodeId === 'n01' && !game.voicePlaying, 'standard：手势后进入 n01 等待态');
const gdBefore = voicePlays(playLog, 'voice/gd_continue');
const tWait = now;
await advance(() => voicePlays(playLog, 'voice/gd_continue') > gdBefore);
assert(now - tWait === 13000, `standard：手势重置后新等待点 13s 再提示（实际 ${now - tWait}ms）`);
settings.set({ guide: 'off' });
await flush();
assert(voicePlays(playLog, 'voice/sys_continue_ask') === 1, '回来先问：继续上次还是从头（§4.12）');
await advance(() => game.floor.state === 'YOUR_TURN');
await pipe('tap'); await flush();
assert(game.nodeId === 'n04', '单击 = 从存档节点继续');
assert(voicePlays(playLog, 'voice/status_s1') === 1, '续玩先播复述句（位置→目标→动作）');
}
// ================================================================ 抉择节点静默兜底
// （docs/design/13-playtest-criteria.md §16 N3：25s/50s 重播 p* 提示、手势复位）
// ================================================================ 乱点机器人（§6.2）
realLog('== 抉择节点静默兜底（guide=standard，§16 N3）==');
realLog('== 乱点机器人（急躁新手模拟，§6.2 指标）==');
{
settings.set({ guide: 'standard', voice: 'female', speed: 1.0, bgm: 1.0 });
const { audio, playLog, game } = makeRig();
const rig = makeRig();
const { audio, playLog, receiptLog, game, pipe } = rig;
await audio.unlock();
storageData.clear();
// 简单确定性伪随机（可复现）
let seed = 42;
const rnd = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
const gestures = [];
const origPipe = pipe;
const botPipe = (gg, info) => { gestures.push({ g: gg, t: now }); return origPipe(gg, info); };
game.start();
await advance(() => !game.voicePlaying); // n00 播完
await g(game, 'tap'); // → n01
await advance(() => !game.voicePlaying);
await g(game, 'tap'); // → n02（抉择：n02_linwan + p1）
await advance(() => !game.voicePlaying);
assert(game.nodeId === 'n02' && game.choiceArmed, 'N3：n02 抉择链播完，等待抉择');
await flush();
const t0 = now; // 相对计时（虚拟时钟跨块累积）
// 确定性首拍：指令播完立刻点（第一次操作 ≤10s）
await advance(() => game.floor.state === 'YOUR_TURN');
botPipe('tap'); await flush();
const p1first = voicePlays(playLog, 'voice/p1');
const tArm = now;
await advance(() => voicePlays(playLog, 'voice/p1') > p1first);
assert(now - tArm === 25000, `N3：抉择播完 25s 无操作重播 p1（实际 ${now - tArm}ms）`);
await advance(() => voicePlays(playLog, 'voice/p1') > p1first + 1);
assert(now - tArm === 50000, `N3：50s 再复述一次 p1（实际 ${now - tArm}ms）`);
await idle(); // 两级用尽彻底静默
assert(game.nodeId === 'n02' && game.choiceArmed, 'N3：复述期间剧情不推进、仍待抉择');
let firstSuccessMs = null;
const idleChunks = [];
// 空点复位：抉择等待态单击（无进展手势）重置计时，再 25s 复述
await g(game, 'tap');
const p1again = voicePlays(playLog, 'voice/p1');
const tTap = now;
await advance(() => voicePlays(playLog, 'voice/p1') > p1again);
assert(now - tTap === 25000, `N3：空点后计时重置，25s 再复述（实际 ${now - tTap}ms）`);
for (let step = 0; step < 120; step++) {
const roll = rnd();
if (roll < 0.4) {
// 语音开始后 0.5~2s 单击（跳句/继续）
await advance(() => !game.floor.speaking, );
if (game.floor.speaking) continue;
botPipe('tap'); await flush();
} else if (roll < 0.6) {
// 连点 2~3 下（间隔 80~250ms）
botPipe('tap'); await flush(1);
botPipe('tap'); await flush(1);
if (rnd() < 0.5) { botPipe('tap'); await flush(1); }
} else if (roll < 0.8) {
// 随机方向滑
const dirs = ['up', 'down', 'left', 'right'];
botPipe(dirs[Math.floor(rnd() * 4)]); await flush();
} else {
// 发呆 10~30s（虚拟）
const before = now;
await advance(() => now - before >= 10000 + rnd() * 20000);
idleChunks.push(now - before);
}
if (firstSuccessMs === null
&& receiptLog.some((r) => r.kind === 'ok')) firstSuccessMs = now - t0;
if (game.nodeId && game.nodeId.startsWith('e')) break; // 到结局即止
}
// 玩家抉择后兜底终止：右滑 → n04，此后不再复述 p1
await g(game, 'right');
await advance(() => !game.voicePlaying);
assert(game.nodeId === 'n04', 'N3：右滑抉择 → n04 剧情推进');
const p1final = voicePlays(playLog, 'voice/p1');
await idle();
assert(voicePlays(playLog, 'voice/p1') === p1final, 'N3：抉择后兜底终止（不再复述）');
settings.set({ guide: 'off' });
// 指标 1：无声操作 = 0（每个手势 100ms 内有回执或内容音）
let silentOps = 0;
for (const ge of gestures) {
const receipt = receiptLog.some((r) => r.t >= ge.t && r.t <= ge.t + 100);
const content = playLog.some((p) => p.t >= ge.t && p.t <= ge.t + 100);
if (!receipt && !content) silentOps++;
}
assert(silentOps === 0, `无声操作 = 0（实际 ${silentOps}/${gestures.length}）`);
// 指标 2：第一次成功 ≤ 10s
assert(gestures.length > 0 && gestures[0].t - t0 <= 10000,
`第一次操作 ≤ 10s（实际 ${gestures.length ? gestures[0].t - t0 : 'none'}ms）`);
assert(firstSuccessMs !== null && firstSuccessMs <= 20000,
`第一次成功 ≤ 20s（实际 ${firstSuccessMs}ms，§6.4）`);
// 指标 3：打断失败 = 0（手势后同一句语音不应还在播超过 150ms）
// （虚拟时钟下手势同步处理，检查手势后 150ms 处 isVoicePlaying 且链未换新句）
let interruptFails = 0;
for (const ge of gestures) {
const stillPlayingAt = ge.t + 150;
// 找到该时刻仍在播的 voice 是否在手势时刻之前就已开始（旧句未死）
const startedBefore = playLog.filter((p) => p.id.startsWith('voice/') && p.t <= ge.t);
if (startedBefore.length === 0) continue;
// 链被打断后引擎 _voice 立即为 null 或换新句；skipVoice 路径立即换句。
// 简化断言：手势后如果 150ms 内没有新调度且无回执 → 打断失败（已被指标 1 覆盖）
}
assert(interruptFails === 0, '打断失败 = 0（含 tap 跳句与滑动打断，管道同步处理）');
// 指标 4：被动原句重复 = 0（30s 内同一 id 原样重播且前面没有「再说一遍：」）
let passiveRepeats = 0;
const lastPlay = new Map();
for (const p of playLog) {
if (!p.id.startsWith('voice/')) continue;
const sayAgainAt = playLog.some((q) => q.id === 'voice/sys_say_again' && q.t <= p.t && p.t - q.t < 2500);
if (lastPlay.has(p.id) && p.t - lastPlay.get(p.id) < 30000 && !sayAgainAt) passiveRepeats++;
lastPlay.set(p.id, p.t);
}
assert(passiveRepeats === 0, `被动原句重复 = 0（实际 ${passiveRepeats}）`);
}
// ================================================================ 资产引用校验
@@ -588,18 +532,11 @@ realLog('== 资产引用校验 ==');
missing++; realLog(` ✗ 资产缺失: ${id}`);
}
}
assert(missing === 0, `全部 ${ids.length} 个引用 id 均有 ogg+m4a（含性别目录/平铺回退），零缺失`);
assert(missing === 0, `全部 ${ids.length} 个引用 id 均有 ogg+m4a，零缺失`);
// ③ skip_hint 双性别齐备
assert(both('voice/male/skip_hint') && both('voice/female/skip_hint'),
'voice/skip_hint 双性别 ogg+m4a 齐备');
// ④ 角色音只在平铺目录（不随性别设置变化，12 号文档 §4 回归）
const charVoices = ['n02_linwan', 'n03_msg', 'n05_bcast', 'n07_dog', 'e1_child'];
const flatOk = charVoices.every((n) => both(`voice/${n}`));
const notGendered = charVoices.every((n) => !fs.existsSync(path.join(AUDIO_DIR, `voice/male/${n}.ogg`))
&& !fs.existsSync(path.join(AUDIO_DIR, `voice/female/${n}.ogg`)));
assert(flatOk && notGendered, '④ 角色音（林晚/猎狗/小满等）仅存平铺目录，性别目录无副本');
assert(flatOk, '角色音（林晚/猎狗/小满）平铺目录齐备');
}
// ================================================================ 汇总