674 lines
28 KiB
JavaScript
674 lines
28 KiB
JavaScript
/**
|
||
* 音序回响（Simon）R2 —— 音频版西蒙记忆游戏（按 docs/design/02-simon-redesign.md 实现）。
|
||
*
|
||
* R2 要点：
|
||
* - 游玩全程无 BGM（用户硬性要求，02 文档既定）：教学/对局/序列播放静默；
|
||
* 仅结算（gameover）与菜单挂 bgm/menu（volume 0.3，比别的游戏更轻，
|
||
* 10 号文档 §4 simon 特例表）；单击/菜单重开时 stopBgm(300) 回静默。
|
||
* - 单击跳过旁白（12 号文档）：voice 播放中单击 = audio.skipVoice()（截断当前句、
|
||
* 语音链继续跳下一句）；无语音时单击 = 原语义。例外：教学"教一个练一个"的
|
||
* 等待输入阶段（teachAwait）单击仍是答题；playback 阶段手势静默忽略、菜单
|
||
* 单击循环菜单项（均维持原裁定）；**结算（gameover）单击不可跳句**——播报
|
||
* 承诺「单击屏幕，再来一局。」，单击必须言行一致直接重开（round1 live P0）。
|
||
* 开场 t0 附近插播一次 voice/skip_hint。
|
||
* - 旁白全部整句化：轮次 round_01..round_20 + round_more 兜底；成绩 score_band1..6
|
||
* 分段整句；删除 di/lun/num_0–9/score_pre/best_pre 拼接体系与旧教学连播。
|
||
* - 交互式教学（T0-T7）：教一个音色练一次该手势，做对才教下一个；教学期下滑跳过。
|
||
* - 播放序列每音配 BEAT 轻震（节拍锚点）；播完 400ms 给 CONFIRM 震动表示"轮到你了"
|
||
* （第 1 轮同时播 your_turn 语音）。
|
||
* - 复活机制：重听分两层账（round2 live P1 改口）——免费重听每局 2 次（教学
|
||
* gd_economy 承诺「免费机会有两次」，先说先给、不碰真机会）；免费用完后
|
||
* 主动重听（input 阶段上滑）才扣 chances。chances 每局初始 1、每完成 4 轮
|
||
* +1（上限 2），答错有机会则自动消耗重播同一序列（序列不重新随机）。
|
||
* - 反馈全部改震动：对/错 SUCCESS/ERROR，sfx/correct、wrong、newrecord 已删除；
|
||
* sfx/gameover 保留为内容性结束音。
|
||
*
|
||
* 设计冲突的处理（round3 synthesis G5 裁定，替代 round2 的双击语境判定）：双击是
|
||
* 六种音色之一（序列可出现 doubletap），历史上又兼「主动重听」。round3 改全局规则：
|
||
* **input 阶段双击永远=作答（第 6 音色）**——期望恰为 doubletap 判对，否则照常判错，
|
||
* 不再承担重听；主动重听改绑**上滑**（期望输入恰为 up 时上滑=作答，六手势全是
|
||
* 答题输入的 00 §5.3 豁免同款）。非输入阶段行为不变（gameover/菜单上滑仍是规则/
|
||
* 帮助）。同一手势在 input 阶段不再有第二种含义（P1 round2 P0 根治）。
|
||
*
|
||
* round4（docs/design/14-guide-layer.md「round4 v1.3」，synthesis H2~H4）：
|
||
* - H2 占用手势预告（round1 live P2 改口）：序列含 up/doubletap 则播
|
||
* gd_occ_up/dt/both（游戏反馈层全档位，插在轮次链中），但**每种组合每局只在
|
||
* 首次出现轮播一次**（原"每轮必念"12 轮连念 12 遍被点名为 P2 不适）；之后仅
|
||
* 在答错消耗机会重听时随 retry_use 重播本轮组合提示。被占用轮次 input 看门狗
|
||
* 只发 nudge earcon 不播重听建议句（say 动态置空）不变。
|
||
* - H3 重听账目真实：主动重听使用时如实报余量（2→1 播 gd_chances_left1、
|
||
* 1→0 播 gd_chances_left0，替换该路径旧「用完了」绝对句，全档位）。
|
||
* - H4 input 看门狗首级 10s→5s（升级级 25s 与次数不变；非 input 阶段不动）。
|
||
*
|
||
* 手势 → 音色映射：
|
||
* up 上行琶音 / down 下行低音 / left 左声道弹拨 / right 右声道弹拨 /
|
||
* tap 底鼓 / doubletap 双连响
|
||
*
|
||
* 语音 id 权威清单：docs/audio/round2-voice-ids.md。
|
||
* 震动分工：玩家手势的识别震动由 gesture.js 内置（swipe/confirm），本层只发
|
||
* 语义震动（beat/confirm/success/error/warning/pickup/hit）。
|
||
*/
|
||
import { Game } from '../engine/game.js';
|
||
import { Guide } from '../engine/guide.js';
|
||
import { vibrate } from '../engine/haptics.js';
|
||
|
||
const GESTURES = ['up', 'down', 'left', 'right', 'tap', 'doubletap'];
|
||
|
||
const TONE = {
|
||
up: 'sfx/tone_up',
|
||
down: 'sfx/tone_down',
|
||
left: 'sfx/tone_left',
|
||
right: 'sfx/tone_right',
|
||
tap: 'sfx/tone_tap',
|
||
doubletap: 'sfx/tone_doubletap',
|
||
};
|
||
|
||
// 教学语音映射（id 用 double，手势名为 doubletap）
|
||
const TEACH_SAY = {
|
||
up: 'voice/t1_up', down: 'voice/t2_down', left: 'voice/t3_left',
|
||
right: 'voice/t4_right', tap: 'voice/t5_tap', doubletap: 'voice/t6_double',
|
||
};
|
||
const TEACH_WRONG = {
|
||
up: 'voice/t_wrong_up', down: 'voice/t_wrong_down', left: 'voice/t_wrong_left',
|
||
right: 'voice/t_wrong_right', tap: 'voice/t_wrong_tap', doubletap: 'voice/t_wrong_double',
|
||
};
|
||
const TEACH_BLUNT = {
|
||
up: 'voice/t_blunt_up', down: 'voice/t_blunt_down', left: 'voice/t_blunt_left',
|
||
right: 'voice/t_blunt_right', tap: 'voice/t_blunt_tap', doubletap: 'voice/t_blunt_double',
|
||
};
|
||
|
||
const BEST_KEY = 'soundgame.simon.best';
|
||
const AUTH_KEY = 'soundgame.auth'; // 大厅登录写入（见 web/index.html）
|
||
|
||
// 表扬句池（既有台词，轮播；round1 live P1：每轮答对必播一句——原 G6 口径
|
||
//「correct 每 4 轮一次 + gd_clear 每局限 1 次」12 轮仅 3 轮有表扬，被推翻）
|
||
const PRAISE = ['voice/correct', 'voice/gd_clear'];
|
||
|
||
// 向导层（14 号文档 + round2 synthesis F1.2 + round4 H4）：input 阶段静默看门狗
|
||
// ——首级 5s 轻提醒 +gd_relisten（H4 round4：10s→5s，P4「10 秒干等」；升级级
|
||
// 不变、次数不变）；25s 升级取消自动重播序列（P1：泄题且与扣机会规则矛盾）→
|
||
// 改为 confirm 震 + turn earcon（纯标记，无语音）
|
||
const GUIDE_INPUT_WATCHDOG_AT = [5000, 25000];
|
||
|
||
export class SimonGame extends Game {
|
||
constructor(audio, root) {
|
||
super(audio, root);
|
||
this.guide = new Guide(audio); // 全局向导层（guide='off' 时全部静默 no-op）
|
||
this.phase = 'idle'; // idle | tutorial | announce | playback | input | roundend | gameover | menu
|
||
this.sequence = [];
|
||
this.round = 0; // 当前轮次（1 起），序列长度 = round + 1
|
||
this.inputIdx = 0;
|
||
this.chances = 1; // 重听机会（初始 1，每 4 轮 +1，上限 2）
|
||
// 免费重听（round2 live P1）：每局 2 次，教学 gd_economy 承诺「免费机会有两次」
|
||
// ——承诺几次给几次，先用免费额度不碰 chances，用完主动重听才扣真机会
|
||
this.freeRelistens = 2;
|
||
this.best = this._loadBest(); // 历史最高（完成轮数），localStorage 持久
|
||
// 教学状态
|
||
this.teachIdx = 0;
|
||
this.teachAwait = false; // 是否正在等玩家做手势
|
||
this.teachErrs = 0;
|
||
// 菜单
|
||
this._menuIdx = 0;
|
||
this._session = 0; // 会话令牌：重开后使旧计时器/语音链回调失效
|
||
this._timers = [];
|
||
// 轮结算反馈：gd_record 每局限 1 次（表扬每轮必播，见 _roundClear）
|
||
this._recordSaid = false;
|
||
// P2（round1 live）：占用组合预告每局每种只播首次（答错时重播，见 _wrongAnswer）
|
||
this._occAnnounced = new Set();
|
||
}
|
||
|
||
start() {
|
||
// 预解码全部短音效与开场语音，消除首次播放延迟
|
||
this.audio.prewarm([
|
||
...GESTURES.map((g) => TONE[g]),
|
||
'sfx/gameover',
|
||
'voice/t0_welcome', 'voice/t0_goal', 'voice/skip_hint', 'voice/t_try', 'voice/round_01',
|
||
]);
|
||
this._timer(() => this._runTutorial(), 500); // 开场静默 0.5s 后进教学（无 BGM）
|
||
}
|
||
|
||
onGesture(g) {
|
||
this.guide.disarm(); // 任何手势复位 input 静默看门狗（guide=off 时 no-op）
|
||
// 单击跳过旁白（12 号文档）：voice 播放中单击 = skipVoice()（截断当前句、
|
||
// 链播自然进下一句）；无语音在播时单击 = 各阶段原语义。跳过不发震动。
|
||
if (g === 'tap' && this._tapSkipsVoice()) {
|
||
this.audio.skipVoice();
|
||
return;
|
||
}
|
||
switch (this.phase) {
|
||
case 'tutorial':
|
||
this._onTutorialGesture(g);
|
||
break;
|
||
case 'input':
|
||
this._onInput(g);
|
||
break;
|
||
case 'gameover':
|
||
if (g === 'tap') this._restart();
|
||
else if (g === 'up') this._speakRules();
|
||
else if (g === 'down') this._openMenu();
|
||
break;
|
||
case 'menu':
|
||
this._onMenuGesture(g);
|
||
break;
|
||
default:
|
||
// playback/announce/roundend：纯聆听阶段手势静默忽略（02 §4.1）
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 单击是否应判定为"跳过当前旁白句"。规则：有 voice 在播 + 当前阶段允许跳过。
|
||
* - tutorial：仅讲解/反馈语音播放中可跳；teachAwait（等玩家练手势）单击=答题；
|
||
* - announce/roundend：轮次/成绩播报可跳（高轮次玩家刚需）；
|
||
* - gameover：**不可跳**——结算播报承诺「单击屏幕，再来一局。」，单击必须
|
||
* 言行一致直接重开（round1 live P0：玩家照播报单击却只跳过一句，随后进
|
||
* 菜单迷路流失）；
|
||
* - playback：维持"序列播放期手势静默忽略"裁定（含第 1 轮 your_turn）；
|
||
* - input：答题阶段无语音；menu：单击循环菜单项是原语义，不拦截。
|
||
* 读引擎的 _voice 字段（只读）判断是否有对白在播；无公开 API，属既定约定。
|
||
*/
|
||
_tapSkipsVoice() {
|
||
if (!this.audio.isVoicePlaying()) return false; // 公开 API（原读私有 _voice，清点 §0）
|
||
switch (this.phase) {
|
||
case 'tutorial': return !this.teachAwait;
|
||
case 'announce':
|
||
case 'roundend': return true;
|
||
default: return false;
|
||
}
|
||
}
|
||
|
||
// ---------------- 交互式教学（T0-T7） ----------------
|
||
|
||
_runTutorial() {
|
||
this.phase = 'tutorial';
|
||
// t0 附近插播一次 skip_hint（"单击可跳过旁白"），每局教学只此一次
|
||
this._speak(['voice/t0_welcome', 'voice/skip_hint', 'voice/t0_goal'], () => this._teachStep(0));
|
||
}
|
||
|
||
/** 教第 i 个手势：指令句 → 播音色 → "你试试。" → 等玩家做该手势。 */
|
||
_teachStep(i) {
|
||
this.teachIdx = i;
|
||
this.teachErrs = 0;
|
||
this.teachAwait = false;
|
||
const g = GESTURES[i];
|
||
const s = this._session;
|
||
this.audio.play(TEACH_SAY[g], {
|
||
onComplete: () => {
|
||
if (s !== this._session || this.phase !== 'tutorial') return;
|
||
this.audio.play(TONE[g]);
|
||
this._timer(() => {
|
||
if (this.phase !== 'tutorial') return;
|
||
this.audio.play('voice/t_try', {
|
||
onComplete: () => {
|
||
if (s === this._session && this.phase === 'tutorial') this.teachAwait = true;
|
||
},
|
||
});
|
||
// t_try 缺失兜底：1.5s 后直接开放输入
|
||
this._timer(() => {
|
||
if (this.phase === 'tutorial') this.teachAwait = true;
|
||
}, 1500);
|
||
}, 900); // 听完音色再请玩家试
|
||
},
|
||
});
|
||
}
|
||
|
||
_onTutorialGesture(g) {
|
||
// 下滑=跳过教学 与 T2"教下滑手势"冲突，按上下文判定（同双击裁定①的思路）：
|
||
// 等待输入阶段且当前教的就是下滑时，下滑=答题；其余教学时刻下滑=跳过。
|
||
if (g === 'down' && !(this.teachAwait && GESTURES[this.teachIdx] === 'down')) {
|
||
this._session++;
|
||
this._clearTimers();
|
||
this.audio.stopVoice();
|
||
this._speak(['voice/t_skip'], () => this._beginGame());
|
||
this._timer(() => { if (this.phase === 'tutorial') this._beginGame(); }, 4000); // 兜底
|
||
return;
|
||
}
|
||
if (!this.teachAwait) return; // 讲解播放中，忽略
|
||
const expected = GESTURES[this.teachIdx];
|
||
if (g === expected) {
|
||
this.teachAwait = false;
|
||
this.audio.play(TONE[g]); // 音色回响（识别震动引擎内置）
|
||
const s = this._session;
|
||
this.audio.play('voice/t_ok', {
|
||
onComplete: () => {
|
||
if (s !== this._session || this.phase !== 'tutorial') return;
|
||
if (this.teachIdx + 1 < GESTURES.length) {
|
||
this._teachStep(this.teachIdx + 1);
|
||
} else {
|
||
// T7：收尾两句 + 机会经济一句（round2 F5 → round3 G5 重录：记不住就
|
||
// 向上滑重新听、免费两次、用完扣机会——P1「经济不透明」开局一句话
|
||
// 讲清，且与新手势映射一致）→ 正式对局
|
||
this._speakGuarded(['voice/t7_ready', 'voice/t7_retry', 'voice/gd_economy'],
|
||
() => this._beginGame(), 20000);
|
||
}
|
||
},
|
||
});
|
||
} else {
|
||
this.teachErrs++;
|
||
vibrate('error');
|
||
if (this.teachErrs >= 3) {
|
||
vibrate('warning');
|
||
this.audio.play(TEACH_BLUNT[expected]); // 错 3 次给更直白描述
|
||
this.teachErrs = 0;
|
||
} else {
|
||
this.audio.play(TEACH_WRONG[expected]);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------------- 对局流程 ----------------
|
||
|
||
_beginGame() {
|
||
this._session++;
|
||
this._clearTimers();
|
||
this.audio.stopVoice(); // 打断残留语音链（onComplete 不触发，链自然作废）
|
||
this.sequence = [];
|
||
this.round = 0;
|
||
this.chances = 1;
|
||
this.freeRelistens = 2; // 免费重听每局重置（round2 live P1）
|
||
this._recordSaid = false;
|
||
this._occAnnounced.clear(); // P2：新一局重新封顶（每种组合首次再播）
|
||
this._nextRound();
|
||
}
|
||
|
||
_restart() {
|
||
this.audio.stopBgm(300); // 停 menu pad，回静默（10 号文档 simon 表）
|
||
this.audio.play('sfx/tone_tap'); // 重开确认音
|
||
this._beginGame(); // 重开跳过教学
|
||
}
|
||
|
||
_nextRound() {
|
||
const s = this._session;
|
||
this.round++;
|
||
if (this.round === 1) {
|
||
this._pushGesture(); // 长度 = round + 1 = 2
|
||
this._pushGesture();
|
||
} else {
|
||
this._pushGesture();
|
||
}
|
||
this.phase = 'announce';
|
||
// 轮次整句：round_01..round_20，超过 20 轮用 round_more 兜底
|
||
const id = this.round <= 20
|
||
? `voice/round_${String(this.round).padStart(2, '0')}`
|
||
: 'voice/round_more';
|
||
let fired = false; // onComplete 与看门狗只准进一次 playback
|
||
const fire = () => {
|
||
if (fired || s !== this._session || this.phase !== 'announce') return;
|
||
fired = true;
|
||
this._playSequence();
|
||
};
|
||
this.audio.play(id, { onComplete: fire });
|
||
// 语音缺失兜底：2.5s 后直接播放序列
|
||
this._timer(fire, 2500);
|
||
}
|
||
|
||
/**
|
||
* 追加一个手势到序列尾部（02 §6.2 约束）：
|
||
* - 第 1 轮两个音不同手势；
|
||
* - 前 5 轮禁止同一手势连续 3 次；
|
||
* - 全部轮次禁止连续 4 个同手势。
|
||
*/
|
||
_pushGesture() {
|
||
const seq = this.sequence;
|
||
let cand = GESTURES[0];
|
||
for (let tries = 0; tries < 20; tries++) {
|
||
cand = GESTURES[Math.floor(Math.random() * GESTURES.length)];
|
||
if (!this._violates(seq, cand)) break;
|
||
}
|
||
seq.push(cand);
|
||
}
|
||
|
||
_violates(seq, cand) {
|
||
const n = seq.length;
|
||
if (this.round === 1 && n === 1 && seq[0] === cand) return true;
|
||
if (this.round <= 5 && n >= 2 && seq[n - 1] === cand && seq[n - 2] === cand) return true;
|
||
if (n >= 3 && seq[n - 1] === cand && seq[n - 2] === cand && seq[n - 3] === cand) return true;
|
||
return false;
|
||
}
|
||
|
||
/** 播放间隔：max(420, 700 - (round-1)*26)，第 12 轮起到 420ms 下限（02 §6.1 + 13 号验收）。 */
|
||
_interval() {
|
||
return Math.max(420, 700 - (this.round - 1) * 26);
|
||
}
|
||
|
||
_playSequence() {
|
||
this.phase = 'playback';
|
||
const s = this._session;
|
||
let i = 0;
|
||
const step = () => {
|
||
if (s !== this._session || this.phase !== 'playback') return;
|
||
if (i < this.sequence.length) {
|
||
this.audio.play(TONE[this.sequence[i]]);
|
||
vibrate('beat'); // 节拍锚点（02 §4.1）
|
||
i++;
|
||
this._timer(step, this._interval());
|
||
} else {
|
||
this._timer(() => {
|
||
if (s !== this._session || this.phase !== 'playback') return;
|
||
vibrate('confirm'); // "轮到你了"
|
||
this.guide.turn({}); // turn earcon 每轮泛化（第 1 轮另有 your_turn 语音，下行）
|
||
// H2（round4）→ round1 live P2 改口：占用预告每种组合每局只播首次
|
||
//（_occAnnounced 记录；之后仅答错重听时随 retry_use 重播，见 _wrongAnswer）。
|
||
// 重听键与答案音共用词表的结构性冲突，换手势无解，改为轮次开场讲清判据。
|
||
let ids = this._occupancyVoices();
|
||
if (ids.length) {
|
||
if (this._occAnnounced.has(ids[0])) ids = [];
|
||
else this._occAnnounced.add(ids[0]);
|
||
}
|
||
if (this.round === 1) ids.push('voice/your_turn');
|
||
if (ids.length) {
|
||
this._speakGuarded(ids, () => {
|
||
if (s === this._session && this.phase === 'playback') this._toInput();
|
||
}, 2500 * ids.length); // 语音缺失兜底：每句 2.5s
|
||
} else {
|
||
this._toInput();
|
||
}
|
||
}, 400); // 最后一个音播完 400ms 后
|
||
}
|
||
};
|
||
step();
|
||
}
|
||
|
||
/**
|
||
* H2（round4）：本轮占用预告句。序列含 up → gd_occ_up、含 doubletap →
|
||
* gd_occ_dt、两者皆有 → gd_occ_both；都不含则不播（空链直达 input）。
|
||
*/
|
||
_occupancyVoices() {
|
||
const hasUp = this.sequence.includes('up');
|
||
const hasDt = this.sequence.includes('doubletap');
|
||
if (hasUp && hasDt) return ['voice/gd_occ_both'];
|
||
if (hasUp) return ['voice/gd_occ_up'];
|
||
if (hasDt) return ['voice/gd_occ_dt'];
|
||
return [];
|
||
}
|
||
|
||
_toInput() {
|
||
this.phase = 'input';
|
||
this.inputIdx = 0;
|
||
// 向导层静默看门狗（round2 F1.2 礼仪重构 + round4 H4/H2）：input 阶段无 BGM
|
||
// 无超时，挂机永久静默。5s → nudge + gd_relisten 提示（H4：首级 10s→5s，
|
||
// P4「10 秒干等」；升级级 25s 与级数不变）；25s 升级**取消免扣机会自动重播
|
||
// 序列**（P1：等答案自动重念，双击重听的经济就矛盾了，还顺手拆了记忆难度）
|
||
// → 只发 confirm 震 + turn earcon（纯标记，无语音）。
|
||
// H2：本轮 up 已被占用为作答时，重听建议句不再建议上滑（实现从简：被占用
|
||
// 轮次看门狗只发 nudge earcon 不播重听建议句）。
|
||
this.guide.watchdog({
|
||
arm: true,
|
||
at: GUIDE_INPUT_WATCHDOG_AT,
|
||
say: [this.sequence.includes('up') ? null : 'gd_relisten', null],
|
||
onEscalate: (n) => { if (n === 2) this.guide.turn({ haptic: true }); },
|
||
cond: () => this.phase === 'input',
|
||
});
|
||
}
|
||
|
||
_onInput(g) {
|
||
// G5（round3）：双击永远=作答（第 6 音色）——期望恰为 doubletap 判对，否则
|
||
// 照常判错，不再承担重听。主动重听改绑上滑：期望输入恰为 up 时上滑=作答
|
||
// （六手势全是答题输入，00 §5.3 豁免同款），其余时刻上滑=主动重听（耗机会）。
|
||
if (g === 'up' && this.sequence[this.inputIdx] !== 'up') {
|
||
this._relisten();
|
||
return;
|
||
}
|
||
// 未支持手势兜底（round1 live P1：答题阶段长按 9 秒零反馈，玩家以为卡死）——
|
||
// 即时 error 震，不判错、不耗机会、不进重听。此前 TONE['longpress'] 为
|
||
// undefined，audio.play(undefined) 直接抛 TypeError（事件回调内静默崩溃，
|
||
// 表象正是"手势被吞"）。longpressend 是同一动作的收尾，静默不重复反馈。
|
||
if (!TONE[g]) {
|
||
if (g !== 'longpressend') vibrate('error');
|
||
return;
|
||
}
|
||
// 立即回声放玩家手势的音色（sfx 低延迟；识别震动引擎内置，不重复震）
|
||
this.audio.play(TONE[g]);
|
||
if (g !== this.sequence[this.inputIdx]) {
|
||
this._wrongAnswer();
|
||
return;
|
||
}
|
||
this.inputIdx++;
|
||
if (this.inputIdx >= this.sequence.length) this._roundClear();
|
||
}
|
||
|
||
/**
|
||
* 主动重听：重播当前序列（进度清零重输，序列不变）。两层账（round2 live P1）：
|
||
* - 免费重听每局 2 次，先用免费额度、**不碰 chances**——教学 gd_economy 承诺
|
||
* 「免费机会有两次」，承诺几次给几次（旧账免费第二次要打完第 4 轮才随
|
||
* chances +1 发放，玩家第 1 次重听就听报「用完了」、答错一题即死，规则级
|
||
* 冤死）。第 1 次用掉（余 1）播 gd_chances_left1「免费重听还剩一次。」、
|
||
* 第 2 次用掉（余 0）播 gd_chances_left0「免费重听用完了。之后重听会花一次
|
||
* 机会，别怕，慢慢来。」（H3 round4 如实报余量，游戏档全级别）。
|
||
* - 免费用完后重听扣 chances（真机会）；扣空（chances 1→0）追加 chances_out
|
||
* 如实报「重听机会用完了，小心。」；免费与真机会皆空时再求重听 → 拒绝
|
||
* （error 震 + chances_out，不判错、不耗账）。
|
||
* 答错自动消耗路径（retry_use + chances_out）是「答错可以消耗机会重听」的
|
||
* 机会账，与主动重听分账，语义如实、维持不变。
|
||
*/
|
||
_relisten() {
|
||
if (this.freeRelistens <= 0 && this.chances <= 0) {
|
||
vibrate('error');
|
||
this.audio.play('voice/chances_out');
|
||
return;
|
||
}
|
||
vibrate('pickup');
|
||
const ids = ['voice/relisten'];
|
||
if (this.freeRelistens > 0) {
|
||
this.freeRelistens--;
|
||
if (this.freeRelistens === 1) ids.push('voice/gd_chances_left1'); // 余 1：还剩一次
|
||
else ids.push('voice/gd_chances_left0'); // 余 0：免费用完，之后扣机会
|
||
} else {
|
||
this.chances--; // 第 3 次起扣真机会
|
||
if (this.chances === 0) ids.push('voice/chances_out'); // 真机会也空了，如实报
|
||
}
|
||
const s = this._session;
|
||
this.phase = 'roundend'; // 重听播报期间暂停接收输入
|
||
this._speakGuarded(ids, () => { if (s === this._session) this._playSequence(); });
|
||
}
|
||
|
||
_roundClear() {
|
||
this.phase = 'roundend';
|
||
const s = this._session;
|
||
vibrate('success');
|
||
// 每轮答对都播一句表扬（PRAISE 池轮播）——round1 live P1：小孩每轮都要听到
|
||
// 一句夸奖，"过关没声音夸我，我都怀疑是不是其实没答对"。
|
||
const ids = [PRAISE[(this.round - 1) % PRAISE.length]];
|
||
// 每完成 4 轮机会 +1（上限 2）并播报
|
||
if (this.round % 4 === 0 && this.chances < 2) {
|
||
this.chances++;
|
||
vibrate('pickup');
|
||
ids.push('voice/chance_plus');
|
||
}
|
||
// gd_record「破纪录了。」每局限 1 次：本轮完成数超过历史最佳（且确有旧纪录
|
||
// 可破）时追加——局中破纪录的即时一刻（结算另有 new_record）。游戏规则句
|
||
// 随链播（全档位，gd_economy 先例），不走向导通道。
|
||
if (!this._recordSaid && this.best > 0 && this.round > this.best) {
|
||
this._recordSaid = true;
|
||
ids.push('voice/gd_record');
|
||
}
|
||
this._speakGuarded(ids, () => {
|
||
if (s !== this._session) return;
|
||
this._timer(() => this._nextRound(), 300);
|
||
});
|
||
}
|
||
|
||
_wrongAnswer() {
|
||
if (this.chances > 0) {
|
||
// 答错且有机会：自动消耗，重播同一序列再试（02 §4.2）
|
||
this.chances--;
|
||
vibrate('error');
|
||
this._timer(() => vibrate('warning'), 300);
|
||
const ids = ['voice/retry_use'];
|
||
if (this.chances === 0) ids.push('voice/chances_out');
|
||
// P2（round1 live）：答错重听时重播本轮组合占用提示（首次播报之后的唯一
|
||
// 重播途径——"能不能只在我答错的时候才提醒我"）
|
||
ids.push(...this._occupancyVoices());
|
||
const s = this._session;
|
||
this.phase = 'roundend';
|
||
this._speakGuarded(ids, () => { if (s === this._session) this._playSequence(); });
|
||
return;
|
||
}
|
||
this._gameOver();
|
||
}
|
||
|
||
_gameOver() {
|
||
this.phase = 'gameover';
|
||
this.guide.state('settle'); // 状态签名：结算（与下方 bgm/menu 同点）
|
||
const s = this._session;
|
||
const score = this.round - 1; // 已完成的轮数
|
||
const isRecord = score > this.best;
|
||
if (isRecord) {
|
||
this.best = score;
|
||
this._saveBest();
|
||
}
|
||
|
||
vibrate('error');
|
||
this._timer(() => vibrate('hit'), 300);
|
||
this._timer(() => {
|
||
if (s === this._session) this.audio.play('sfx/gameover');
|
||
}, 700);
|
||
|
||
const ids = ['voice/gameover', this._scoreBandVoice(score)];
|
||
if (isRecord) ids.push('voice/new_record');
|
||
ids.push('voice/replay', 'voice/rules_prompt');
|
||
this._timer(() => {
|
||
if (s === this._session) this._speak(ids, null); // 链播完停在 gameover，等手势
|
||
}, 1400);
|
||
|
||
// 状态 BGM（10 号文档 simon 表）：sfx/gameover（约 0.95s，+700ms 起播）
|
||
// 播完 1s 后淡入 menu pad 1000ms，音量 0.3。若玩家已进菜单/重开则不补播。
|
||
this._timer(() => {
|
||
if (s === this._session && this.phase === 'gameover') {
|
||
this.audio.play('bgm/menu', { volume: 0.3, fadeMs: 1000 });
|
||
}
|
||
}, 700 + 950 + 1000);
|
||
}
|
||
|
||
/** 成绩分段整句：0 / 1-3 / 4-6 / 7-9 / 10-14 / ≥15（02 §3.2）。 */
|
||
_scoreBandVoice(score) {
|
||
if (score <= 0) return 'voice/score_band1';
|
||
if (score <= 3) return 'voice/score_band2';
|
||
if (score <= 6) return 'voice/score_band3';
|
||
if (score <= 9) return 'voice/score_band4';
|
||
if (score <= 14) return 'voice/score_band5';
|
||
return 'voice/score_band6';
|
||
}
|
||
|
||
_speakRules() {
|
||
this._speak(['voice/rules', 'voice/rules_prompt'], null);
|
||
}
|
||
|
||
// ---------------- 菜单 ----------------
|
||
|
||
_openMenu() {
|
||
this._menuIdx = 0;
|
||
this.phase = 'menu';
|
||
this.guide.state('menu'); // 状态签名：菜单（与下方 bgm/menu 同点）
|
||
// 状态 BGM：菜单挂 menu pad（volume 0.3，淡入 600ms；与结算同一首，引擎不重启）
|
||
this.audio.play('bgm/menu', { volume: 0.3, fadeMs: 600 });
|
||
this._speak(['voice/menu_open', 'voice/menu_restart'], null);
|
||
}
|
||
|
||
_onMenuGesture(g) {
|
||
const items = ['voice/menu_restart', 'voice/menu_home', 'voice/menu_back'];
|
||
// 单击/右滑=下一项、左滑=上一项，切换即播报当前项（round1 live P1：原来
|
||
// 左右滑只有震动没有语音，"不知道有几项、指在哪项"）
|
||
if (g === 'tap' || g === 'right') {
|
||
this._menuIdx = (this._menuIdx + 1) % items.length;
|
||
this.audio.play(items[this._menuIdx]);
|
||
} else if (g === 'left') {
|
||
this._menuIdx = (this._menuIdx + items.length - 1) % items.length;
|
||
this.audio.play(items[this._menuIdx]);
|
||
} else if (g === 'up') {
|
||
this._speakRules();
|
||
} else if (g === 'down') {
|
||
this.phase = 'gameover'; // 下滑=关闭菜单回结算页（13 号文档 §7.5 菜单约定）
|
||
} else if (g === 'doubletap') {
|
||
const sel = this._menuIdx;
|
||
if (sel === 0) this._restart();
|
||
else if (sel === 1) { this.stop(); window.location.href = '../'; }
|
||
else this.phase = 'gameover'; // 返回：回到结算页
|
||
}
|
||
}
|
||
|
||
// ---------------- 成绩存档 ----------------
|
||
|
||
_loadBest() {
|
||
try {
|
||
return Number(localStorage.getItem(BEST_KEY)) || 0;
|
||
} catch (_) {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/** 破纪录：写 localStorage + （已登录时）同步服务器。 */
|
||
_saveBest() {
|
||
try { localStorage.setItem(BEST_KEY, String(this.best)); } catch (_) { /* 隐私模式 */ }
|
||
try {
|
||
const auth = JSON.parse(localStorage.getItem(AUTH_KEY));
|
||
if (!auth || !auth.token) return;
|
||
fetch('/api/progress', {
|
||
method: 'PUT',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
'Authorization': 'Bearer ' + auth.token,
|
||
},
|
||
body: JSON.stringify({
|
||
game: 'simon',
|
||
data: {
|
||
summary: `最佳成绩：第 ${this.best} 轮`,
|
||
bestRound: this.best,
|
||
schema: 1,
|
||
updatedAt: new Date().toISOString(),
|
||
},
|
||
}),
|
||
}).catch(() => { /* 离线静默 */ });
|
||
} catch (_) { /* 静默 */ }
|
||
}
|
||
|
||
// ---------------- 工具 ----------------
|
||
|
||
/** 语音串行链：自然播完才接下一句；被 stopVoice 打断则整条作废。 */
|
||
_speak(ids, onDone) {
|
||
if (!ids.length) { if (onDone) onDone(); return; }
|
||
const s = this._session;
|
||
const [head, ...rest] = ids;
|
||
this.audio.play(head, {
|
||
onComplete: () => {
|
||
if (s !== this._session) return;
|
||
this._speak(rest, onDone);
|
||
},
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 带看门狗的语音链：链自然播完或 guardMs 超时（语音缺失/解码失败），
|
||
* 二者先到先触发 onDone 且只触发一次——保证对局流程绝不卡死。
|
||
*/
|
||
_speakGuarded(ids, onDone, guardMs = 10000) {
|
||
const s = this._session;
|
||
let fired = false;
|
||
const fire = () => {
|
||
if (fired || s !== this._session) return;
|
||
fired = true;
|
||
if (onDone) onDone();
|
||
};
|
||
this._speak(ids, fire);
|
||
this._timer(fire, guardMs);
|
||
}
|
||
|
||
_timer(fn, ms) {
|
||
const s = this._session;
|
||
const id = setTimeout(() => { if (s === this._session) fn(); }, ms);
|
||
this._timers.push(id);
|
||
return id;
|
||
}
|
||
|
||
_clearTimers() {
|
||
for (const id of this._timers) clearTimeout(id);
|
||
this._timers.length = 0;
|
||
}
|
||
|
||
stop() {
|
||
this._session++;
|
||
this._clearTimers();
|
||
this.audio.stopAll();
|
||
}
|
||
}
|