@zhin.js/plugin-roulette 0.1.4 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # @zhin.js/plugin-roulette
 
+## 0.1.6
+
+### Patch Changes
+
+- Updated dependencies [f67883e]
+- Updated dependencies [4d728c0]
+- Updated dependencies [24a2b71]
+- Updated dependencies [3771f7a]
+- Updated dependencies [4f96ad5]
+  - @zhin.js/core@1.1.52
+  - @zhin.js/game-kit@1.1.17
+
+## 0.1.5
+
+### Patch Changes
+
+- 9cade30: 修复国际化调用链遗漏：Agent 审批、管理命令和错误反馈采用可信语言及实际命令前缀；游戏快捷帮助、工具反馈、平台默认卡片和后台通知贯通语言。协议即时回复复用受运行代约束的个人语言查询，业务验证支持不改变审批身份的双语展示元数据。
+
+  AI 正文、进度与耗尽摘要统一优先遵从用户明确语言要求，再跟随实际输入；个人／项目语言仅作兜底，固定界面文案继续使用配置语言，不增加翻译调用。
+
+  GitHub 工作区为 Git clone/pull/fetch/ls-remote 显式分隔选项与位置参数，保留仓库和分支校验；顺序写入 Bot 名称和邮箱，避免竞争同一配置文件锁。
+
+- 53bc6a0: 官方工具插件与游戏支持中英文反馈、帮助和配置标签；提醒增加与中文对应的有限英文时间语法。聊天后台任务记录创建者当时语言，管理员任务记录项目语言，旧任务保持中文；多轮选择与游戏使用开始时语言，保留第三方内容和已生成报告。
+- Updated dependencies [18296cf]
+- Updated dependencies [08e64de]
+- Updated dependencies [9cade30]
+- Updated dependencies [53bc6a0]
+- Updated dependencies [53bc6a0]
+- Updated dependencies [66b6404]
+- Updated dependencies [adb4af2]
+- Updated dependencies [69f9ef6]
+- Updated dependencies [17d1301]
+  - @zhin.js/core@1.1.51
+  - @zhin.js/game-kit@1.1.16
+
 ## 0.1.4
 
 ### Patch Changes

package/commands/roulette/[[action]]/index.js

@@ -1,13 +1,14 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
+import { gameCommandFeedback } from '@zhin.js/game-kit';
 import { defineCommand } from 'zhin.js/command';
-import { ROULETTE_HELP } from "../../../lib/roulette-actions.js";
+import { getRouletteHelp } from "../../../lib/roulette-actions.js";
 import { runRouletteCommand } from "../../../lib/roulette-command.js";
 export default defineCommand({
-    description: '俄罗斯轮盘：多人轮流开枪，中弹者输',
+    description: '俄罗斯轮盘：多人轮流开枪，中弹者输', descriptionI18n: { en: "Russian roulette: take turns; the player hit loses" },
     params: { action: { type: 'string', default: '' } },
     async execute(context) {
         const action = String(context.params.action ?? '');
         const reply = await runRouletteCommand(context, context.input, action);
-        return reply ?? `未知操作：${action}\n\n${ROULETTE_HELP}`;
+        return reply ?? gameCommandFeedback(context, 'unknown', action) + '\n\n' + getRouletteHelp(context);
     },
 });

package/lib/deadline-job.js

@@ -1,4 +1,5 @@
 import { outboundHostToken } from 'zhin.js';
+import { resolveLocale } from 'zhin.js/i18n';
 import { expireOverdueSessions } from './game-flow.js';
 import { resolveRouletteFlow } from './runtime.js';
 /** Turn and lobby deadlines are checked every five seconds. */
@@ -28,6 +29,7 @@ async function announce(outbound, notice) {
     const session = notice.session;
     try {
         await outbound.send({
+            locale: resolveLocale(session.locale),
             adapter: session.adapter,
             endpointKey: session.endpoint,
             conversation: {

package/lib/engine.d.ts

@@ -1,3 +1,4 @@
+import { type Locale } from 'zhin.js/i18n';
 /**
  * Pure Russian roulette rules. No I/O, no clock and no randomness: callers pass
  * the bullet position in, so every transition is deterministic and testable.
@@ -37,7 +38,10 @@ export interface TriggerResult {
 }
 /** A rule violation the player should read, e.g. firing out of turn. */
 export declare class RouletteRuleError extends Error {
-    constructor(message: string);
+    readonly code: RouletteRuleCode;
+    readonly parameters: Readonly<Record<string, string | number>>;
+    constructor(code: RouletteRuleCode, parameters?: Readonly<Record<string, string | number>>);
+    format(locale?: Locale): string;
 }
 export declare function createLobby(host: RoulettePlayer, rules: RouletteTableRules): RouletteState;
 export declare function joinLobby(state: RouletteState, player: RoulettePlayer, rules: RouletteTableRules): RouletteState;
@@ -59,3 +63,51 @@ export declare function loserOf(state: RouletteState): RoulettePlayer | undefine
 export declare function survivorsOf(state: RouletteState): readonly RoulettePlayer[];
 export declare function remainingChambers(state: RouletteState): number;
 export declare function decodeRouletteState(json: string): RouletteState;
+declare const ruleCatalog: {
+    readonly cannotJoin: {
+        readonly 'zh-CN': "对局已经开始，不能再加入了。";
+        readonly en: "The game has started; you can no longer join.";
+    };
+    readonly alreadyJoined: {
+        readonly 'zh-CN': "你已经在这局轮盘里了。";
+        readonly en: "You are already in this game.";
+    };
+    readonly full: {
+        readonly 'zh-CN': "人数已满（最多 {max} 人）。";
+        readonly en: "The table is full (maximum {max} players).";
+    };
+    readonly started: {
+        readonly 'zh-CN': "对局已经开始了。";
+        readonly en: "The game has already started.";
+    };
+    readonly hostOnly: {
+        readonly 'zh-CN': "只有开局的人可以开始。";
+        readonly en: "Only the host may start the game.";
+    };
+    readonly minimum: {
+        readonly 'zh-CN': "至少需要 {min} 名玩家才能开始。";
+        readonly en: "At least {min} players are required.";
+    };
+    readonly notStarted: {
+        readonly 'zh-CN': "对局还没开始。";
+        readonly en: "The game has not started.";
+    };
+    readonly noPlayer: {
+        readonly 'zh-CN': "对局没有可以开枪的玩家。";
+        readonly en: "There is no player who can pull the trigger.";
+    };
+    readonly notTurn: {
+        readonly 'zh-CN': "还没轮到你，现在轮到 {name}。";
+        readonly en: "It is not your turn. {name} plays next.";
+    };
+    readonly notJoined: {
+        readonly 'zh-CN': "你不在这局轮盘里。";
+        readonly en: "You are not in this game.";
+    };
+    readonly ended: {
+        readonly 'zh-CN': "对局已经结束。";
+        readonly en: "The game has ended.";
+    };
+};
+type RouletteRuleCode = keyof typeof ruleCatalog;
+export {};

package/lib/engine.js

@@ -1,3 +1,4 @@
+import { createMessages } from 'zhin.js/i18n';
 /**
  * Pure Russian roulette rules. No I/O, no clock and no randomness: callers pass
  * the bullet position in, so every transition is deterministic and testable.
@@ -6,10 +7,15 @@ export const ROULETTE_STATE_VERSION = 1;
 export const MIN_ROULETTE_PLAYERS = 2;
 /** A rule violation the player should read, e.g. firing out of turn. */
 export class RouletteRuleError extends Error {
-    constructor(message) {
-        super(message);
+    code;
+    parameters;
+    constructor(code, parameters = {}) {
+        super(ruleMessages('zh-CN', code, parameters));
+        this.code = code;
+        this.parameters = parameters;
         this.name = 'RouletteRuleError';
     }
+    format(locale) { return ruleMessages(locale, this.code, this.parameters); }
 }
 export function createLobby(host, rules) {
     return {
@@ -24,22 +30,22 @@ export function createLobby(host, rules) {
     };
 }
 export function joinLobby(state, player, rules) {
-    requirePhase(state, 'lobby', '对局已经开始，不能再加入了。');
+    requirePhase(state, 'lobby', 'cannotJoin');
     if (findPlayer(state, player.id)) {
-        throw new RouletteRuleError('你已经在这局轮盘里了。');
+        throw new RouletteRuleError('alreadyJoined');
     }
     if (state.players.length >= rules.maxPlayers) {
-        throw new RouletteRuleError(`人数已满（最多 ${rules.maxPlayers} 人）。`);
+        throw new RouletteRuleError('full', { max: rules.maxPlayers });
     }
     return { ...state, players: [...state.players, player] };
 }
 export function startRound(state, actorId, bulletChamber) {
-    requirePhase(state, 'lobby', '对局已经开始了。');
+    requirePhase(state, 'lobby', 'started');
     if (actorId !== state.hostId) {
-        throw new RouletteRuleError('只有开局的人可以开始。');
+        throw new RouletteRuleError('hostOnly');
     }
     if (state.players.length < MIN_ROULETTE_PLAYERS) {
-        throw new RouletteRuleError(`至少需要 ${MIN_ROULETTE_PLAYERS} 名玩家才能开始。`);
+        throw new RouletteRuleError('minimum', { min: MIN_ROULETTE_PLAYERS });
     }
     if (!Number.isInteger(bulletChamber) || bulletChamber < 0 || bulletChamber >= state.chamberCount) {
         throw new RangeError(`bulletChamber must be within 0..${state.chamberCount - 1}`);
@@ -53,12 +59,12 @@ export function startRound(state, actorId, bulletChamber) {
     };
 }
 export function pullTrigger(state, actorId) {
-    requirePhase(state, 'playing', '对局还没开始。');
+    requirePhase(state, 'playing', 'notStarted');
     const shooter = currentPlayer(state);
     if (!shooter)
-        throw new RouletteRuleError('对局没有可以开枪的玩家。');
+        throw new RouletteRuleError('noPlayer');
     if (shooter.id !== actorId) {
-        throw new RouletteRuleError(`还没轮到你，现在轮到 ${shooter.name}。`);
+        throw new RouletteRuleError('notTurn', { name: shooter.name });
     }
     const firedChamber = state.pullsMade;
     const pullsMade = state.pullsMade + 1;
@@ -76,11 +82,11 @@ export function pullTrigger(state, actorId) {
 export function leaveGame(state, playerId) {
     const leaver = findPlayer(state, playerId);
     if (!leaver)
-        throw new RouletteRuleError('你不在这局轮盘里。');
+        throw new RouletteRuleError('notJoined');
     if (state.phase === 'playing') {
         return finishWithLoser(state, playerId, 'forfeit');
     }
-    requirePhase(state, 'lobby', '对局已经结束。');
+    requirePhase(state, 'lobby', 'ended');
     const players = state.players.filter((player) => player.id !== playerId);
     const nextHost = players[0];
     if (!nextHost) {
@@ -91,19 +97,19 @@ export function leaveGame(state, playerId) {
 }
 /** The player on turn ran out of time: treated like a shot, they lose. */
 export function expireTurn(state) {
-    requirePhase(state, 'playing', '对局还没开始。');
+    requirePhase(state, 'playing', 'notStarted');
     const late = currentPlayer(state);
     if (!late)
-        throw new RouletteRuleError('对局没有可以开枪的玩家。');
+        throw new RouletteRuleError('noPlayer');
     return finishWithLoser(state, late.id, 'turn-timeout');
 }
 export function expireLobby(state) {
-    requirePhase(state, 'lobby', '对局已经开始了。');
+    requirePhase(state, 'lobby', 'started');
     return { ...state, phase: 'aborted', endReason: 'lobby-expired' };
 }
 export function cancelGame(state) {
     if (!isOpen(state))
-        throw new RouletteRuleError('对局已经结束。');
+        throw new RouletteRuleError('ended');
     return { ...state, phase: 'aborted', endReason: 'cancelled' };
 }
 export function isOpen(state) {
@@ -138,9 +144,9 @@ export function decodeRouletteState(json) {
 function finishWithLoser(state, loserId, endReason) {
     return { ...state, phase: 'finished', loserId, endReason };
 }
-function requirePhase(state, phase, message) {
+function requirePhase(state, phase, code) {
     if (state.phase !== phase)
-        throw new RouletteRuleError(message);
+        throw new RouletteRuleError(code);
 }
 function isRouletteState(value) {
     if (!value || typeof value !== 'object')
@@ -155,3 +161,17 @@ function isRouletteState(value) {
         && typeof state.pullsMade === 'number'
         && typeof state.turnIndex === 'number';
 }
+const ruleCatalog = {
+    cannotJoin: { 'zh-CN': "对局已经开始，不能再加入了。", en: "The game has started; you can no longer join." },
+    alreadyJoined: { 'zh-CN': "你已经在这局轮盘里了。", en: "You are already in this game." },
+    full: { 'zh-CN': "人数已满（最多 {max} 人）。", en: "The table is full (maximum {max} players)." },
+    started: { 'zh-CN': "对局已经开始了。", en: "The game has already started." },
+    hostOnly: { 'zh-CN': "只有开局的人可以开始。", en: "Only the host may start the game." },
+    minimum: { 'zh-CN': "至少需要 {min} 名玩家才能开始。", en: "At least {min} players are required." },
+    notStarted: { 'zh-CN': "对局还没开始。", en: "The game has not started." },
+    noPlayer: { 'zh-CN': "对局没有可以开枪的玩家。", en: "There is no player who can pull the trigger." },
+    notTurn: { 'zh-CN': "还没轮到你，现在轮到 {name}。", en: "It is not your turn. {name} plays next." },
+    notJoined: { 'zh-CN': "你不在这局轮盘里。", en: "You are not in this game." },
+    ended: { 'zh-CN': "对局已经结束。", en: "The game has ended." },
+};
+const ruleMessages = createMessages(ruleCatalog);

package/lib/game-flow.js

@@ -1,17 +1,19 @@
-import { GameSessionConflictError, SessionRevisionConflictError, channelKey, } from '@zhin.js/game-kit';
+import { createMessages, resolveLocale } from 'zhin.js/i18n';
+import { gameCommandHint, GameSessionConflictError, SessionRevisionConflictError, channelKey } from '@zhin.js/game-kit';
 import { RouletteRuleError, loserOf } from './engine.js';
-import { ROULETTE_HELP } from './roulette-actions.js';
+import { getRouletteHelp } from './roulette-actions.js';
 import { playerFromMessage, stateOf, } from './session-service.js';
 import { describeAbort, describeClick, describeEnding, describeLobby, describeRoundStart, describeStatus, } from './view.js';
 const DEADLINE_ACTOR = 'deadline';
 const MANAGER_ROLES = ['master', 'trusted', 'owner', 'admin'];
-const NO_GAME_TEXT = '本群没有进行中的轮盘，发送「轮盘 开局」创建一局。';
+function noGame(message) { return messages(message.locale, 'noGame') + gameCommandHint(message, 'roulette', 'open'); }
 export async function runRouletteAction(flow, actor, action) {
     const message = actor.message;
+    const locale = resolveLocale(message.locale);
     if (action === 'help')
-        return ROULETTE_HELP;
+        return getRouletteHelp(message);
     if (message.$channel.type === 'private')
-        return '轮盘需要多人参与，请在群聊里玩。';
+        return messages(locale, 'text1');
     if (action === 'penalty-on' || action === 'penalty-off' || action === 'penalty-status') {
         return handlePenaltySetting(flow, actor, action);
     }
@@ -51,63 +53,67 @@ export async function expireOverdueSessions(flow, now, onNotice) {
 }
 async function handleGameAction(flow, actor, action, session) {
     const message = actor.message;
+    const locale = resolveLocale(session ? session.locale : message.locale);
     if (action === 'open')
         return openLobby(flow, actor, session);
     if (!session)
-        return NO_GAME_TEXT;
+        return noGame(message);
     if (action === 'status')
-        return describeStatus(stateOf(session), flow.config);
+        return describeStatus(stateOf(session), flow.config, { ...message, locale });
     if (action === 'cancel' && !mayCancel(session, message, actor.roles)) {
-        return '只有开局的人、群主、群管理员或机器人管理员可以取消本局。';
+        return messages(locale, 'text2');
     }
     const gameAction = toGameAction(action, message);
     if (!gameAction)
-        return NO_GAME_TEXT;
+        return noGame(message);
     try {
         const result = await flow.services.sessions.applyAction(session, message.$sender.id, gameAction, flow.config);
         return describeResult(flow, gameAction, result, message);
     }
     catch (error) {
         if (error instanceof RouletteRuleError)
-            return error.message;
+            return error.format(locale);
         if (error instanceof GameSessionConflictError)
-            return error.message;
+            return error.format(locale);
         if (error instanceof SessionRevisionConflictError)
-            return '对局状态刚刚变了，请再发一次。';
+            return messages(locale, 'text3');
         throw error;
     }
 }
 async function openLobby(flow, actor, session) {
+    const locale = resolveLocale(session ? session.locale : actor.message.locale);
     if (session) {
-        return `本群已经有一局轮盘了。\n${describeStatus(stateOf(session), flow.config)}`;
+        return messages(locale, 'text4', { p0: describeStatus(stateOf(session), flow.config, { ...actor.message, locale }) });
     }
     try {
         const created = await flow.services.sessions.createLobby(actor.message, actor.endpoint, flow.config);
-        return describeLobby(stateOf(created), flow.config);
+        return describeLobby(stateOf(created), flow.config, { ...actor.message, locale });
     }
     catch (error) {
         if (error instanceof GameSessionConflictError)
-            return error.message;
+            return error.format(locale);
         throw error;
     }
 }
 async function describeResult(flow, action, result, message) {
     const state = result.state;
+    const locale = resolveLocale(result.session.locale);
+    const presentation = { ...message, locale };
     if (!result.applied)
-        return describeStatus(state, flow.config);
+        return describeStatus(state, flow.config, presentation);
     if (state.phase === 'finished')
         return finishText(flow, result.session, state);
     if (state.phase === 'aborted')
-        return describeAbort(state);
+        return describeAbort(state, presentation);
     if (action.type === 'start')
-        return describeRoundStart(state, flow.config);
+        return describeRoundStart(state, flow.config, presentation);
     if (action.type === 'fire') {
-        return describeClick(playerFromMessage(message), state, flow.config);
+        return describeClick(playerFromMessage(message), state, flow.config, presentation);
     }
     if (action.type === 'leave') {
-        return `${playerFromMessage(message).name} 离开了。\n${describeLobby(state, flow.config)}`;
+        return messages(locale, 'text5', { p0: playerFromMessage(message).name, p1: describeLobby(state, flow.config, presentation) });
     }
-    return describeLobby(state, flow.config);
+    return describeLobby(state, flow.config, presentation);
 }
 async function expireSession(flow, session) {
     // Read everything that can fail before the state transition is committed: once the
@@ -121,7 +127,7 @@ async function expireSession(flow, session) {
             return '';
         if (result.state.phase === 'finished')
             return finishText(flow, result.session, result.state, penaltyEnabled);
-        return describeAbort(result.state);
+        return describeAbort(result.state, { locale: resolveLocale(result.session.locale) });
     }
     catch (error) {
         // A player acted on the session in the meantime; the next sweep re-reads it.
@@ -132,10 +138,11 @@ async function expireSession(flow, session) {
 }
 async function finishText(flow, session, state, penaltyEnabled) {
     const penalty = await applyLoserPenalty(flow, session, state, penaltyEnabled);
-    return [describeEnding(state), penalty].filter(Boolean).join('\n');
+    return [describeEnding(state, { locale: resolveLocale(session.locale) }), penalty].filter(Boolean).join('\n');
 }
 /** Mute the loser only when this group opted in and the Endpoint declares muting. */
 async function applyLoserPenalty(flow, session, state, penaltyEnabled) {
+    const locale = resolveLocale(session.locale);
     const loser = loserOf(state);
     if (!loser)
         return '';
@@ -145,44 +152,45 @@ async function applyLoserPenalty(flow, session, state, penaltyEnabled) {
         return '';
     const conversation = conversationOfSession(session);
     if (flow.penalty.support(conversation) !== 'supported') {
-        return '（本群开启了禁言惩罚，但当前平台无法禁言，本局只计分。）';
+        return messages(locale, 'text6');
     }
     try {
         await flow.penalty.mute(conversation, loser.id, flow.config.muteSeconds);
-        return `🔇 ${loser.name} 被禁言 ${flow.config.muteSeconds} 秒。`;
+        return messages(locale, 'text7', { p0: loser.name, p1: flow.config.muteSeconds });
     }
     catch {
-        return '（禁言没有成功，可能是机器人没有群管理权限；本局只计分。）';
+        return messages(locale, 'text8');
     }
 }
 async function handlePenaltySetting(flow, actor, action) {
     const message = actor.message;
+    const locale = resolveLocale(message.locale);
     if (message.$channel.type !== 'group')
-        return '禁言惩罚只能在群聊里设置。';
+        return messages(locale, 'text9');
     const key = channelKey(message);
     const settings = flow.services.settings;
     const support = flow.penalty.support(conversationOfActor(actor));
     if (action === 'penalty-status') {
         const enabled = await settings.isMutePenaltyEnabled(key);
-        return describePenaltyStatus(enabled, support === 'supported', flow.config);
+        return describePenaltyStatus(enabled, support === 'supported', flow.config, locale);
     }
     if (!isManager(actor.roles))
-        return '只有群主、群管理员、机器人主人或受信任用户可以修改禁言惩罚。';
+        return messages(locale, 'text10');
     if (action === 'penalty-off') {
         await settings.setMutePenalty(key, false, message.$sender.id);
-        return '已关闭禁言惩罚，本群轮盘只计分。';
+        return messages(locale, 'text11');
     }
     if (support !== 'supported') {
-        return '当前平台不支持禁言，禁言惩罚没有开启；本群轮盘只计分。';
+        return messages(locale, 'text12');
     }
     await settings.setMutePenalty(key, true, message.$sender.id);
-    return `已开启禁言惩罚：每局输家会被禁言 ${flow.config.muteSeconds} 秒（需要机器人有群管理权限）。`;
+    return messages(locale, 'text13', { p0: flow.config.muteSeconds });
 }
-function describePenaltyStatus(enabled, supported, config) {
-    const platform = supported ? '当前平台支持禁言。' : '当前平台不支持禁言，只能计分。';
+function describePenaltyStatus(enabled, supported, config, locale) {
+    const platform = supported ? messages(locale, 'text14') : messages(locale, 'text15');
     if (!enabled)
-        return `本群禁言惩罚：关闭。${platform}`;
-    return `本群禁言惩罚：开启，输家禁言 ${config.muteSeconds} 秒。${platform}`;
+        return messages(locale, 'text16', { p0: platform });
+    return messages(locale, 'text17', { p0: config.muteSeconds, p1: platform });
 }
 function toGameAction(action, message) {
     if (action === 'join')
@@ -224,3 +232,23 @@ function conversationOfActor(actor) {
         id: actor.message.$channel.id,
     };
 }
+const messages = createMessages({
+    noGame: { 'zh-CN': '本群没有进行中的轮盘。', en: 'This group has no active roulette game.' },
+    text1: { 'zh-CN': "轮盘需要多人参与，请在群聊里玩。", en: "Roulette needs multiple players. Please play in a group chat." },
+    text2: { 'zh-CN': "只有开局的人、群主、群管理员或机器人管理员可以取消本局。", en: "Only the host, group owner, group admin or bot administrator may cancel this game." },
+    text3: { 'zh-CN': "对局状态刚刚变了，请再发一次。", en: "The game state just changed. Please try again." },
+    text4: { 'zh-CN': "本群已经有一局轮盘了。\n{p0}", en: "This group already has a roulette game.\n{p0}" },
+    text5: { 'zh-CN': "{p0} 离开了。\n{p1}", en: "{p0} left.\n{p1}" },
+    text6: { 'zh-CN': "（本群开启了禁言惩罚，但当前平台无法禁言，本局只计分。）", en: "(Mute penalties are enabled, but this platform cannot mute players. Only scores were recorded.)" },
+    text7: { 'zh-CN': "🔇 {p0} 被禁言 {p1} 秒。", en: "🔇 {p0} was muted for {p1} seconds." },
+    text8: { 'zh-CN': "（禁言没有成功，可能是机器人没有群管理权限；本局只计分。）", en: "(Muting failed, possibly because the bot lacks group management permission. Only scores were recorded.)" },
+    text9: { 'zh-CN': "禁言惩罚只能在群聊里设置。", en: "Mute penalties can only be configured in a group chat." },
+    text10: { 'zh-CN': "只有群主、群管理员、机器人主人或受信任用户可以修改禁言惩罚。", en: "Only the group owner, group admin, bot owner or a trusted user may change mute penalties." },
+    text11: { 'zh-CN': "已关闭禁言惩罚，本群轮盘只计分。", en: "Mute penalties are disabled. This group now records scores only." },
+    text12: { 'zh-CN': "当前平台不支持禁言，禁言惩罚没有开启；本群轮盘只计分。", en: "This platform does not support muting. Mute penalties remain disabled; only scores are recorded." },
+    text13: { 'zh-CN': "已开启禁言惩罚：每局输家会被禁言 {p0} 秒（需要机器人有群管理权限）。", en: "Mute penalties enabled: each loser is muted for {p0} seconds (the bot needs group management permission)." },
+    text14: { 'zh-CN': "当前平台支持禁言。", en: "This platform supports muting." },
+    text15: { 'zh-CN': "当前平台不支持禁言，只能计分。", en: "This platform does not support muting; only scores are recorded." },
+    text16: { 'zh-CN': "本群禁言惩罚：关闭。{p0}", en: "Group mute penalty: off. {p0}" },
+    text17: { 'zh-CN': "本群禁言惩罚：开启，输家禁言 {p0} 秒。{p1}", en: "Group mute penalty: on, the loser is muted for {p0} seconds. {p1}" },
+});

package/lib/models.d.ts

@@ -4,6 +4,7 @@ declare module '@zhin.js/core' {
     interface Models {
         roulette_sessions: {
             id: string;
+            locale?: 'zh-CN' | 'en' | null;
             adapter: string;
             endpoint: string;
             channel_type: string;
@@ -37,5 +38,7 @@ export type RouletteSessionRow = Models['roulette_sessions'];
 export type RouletteGroupSettingsRow = Models['roulette_group_settings'];
 export declare const ROULETTE_TABLES: readonly ["roulette_sessions", "roulette_group_settings"];
 export declare function defineHostTables(database: {
-    define(name: string, definition: Record<string, unknown>): void;
+    define(name: string, definition: Record<string, unknown>, options?: {
+        readonly addColumns?: readonly string[];
+    }): void;
 }): void;

package/lib/models.js

@@ -2,6 +2,7 @@ export const ROULETTE_TABLES = ['roulette_sessions', 'roulette_group_settings'];
 export function defineHostTables(database) {
     database.define('roulette_sessions', {
         id: { type: 'text', primary: true },
+        locale: { type: 'text', nullable: true },
         adapter: { type: 'text', nullable: false },
         endpoint: { type: 'text', nullable: false },
         channel_type: { type: 'text', nullable: false },
@@ -19,7 +20,7 @@ export function defineHostTables(database) {
         status: { type: 'text', default: 'active' },
         updated_at: { type: 'bigint', default: 0 },
         created_at: { type: 'bigint', default: 0 },
-    });
+    }, { addColumns: ['locale'] });
     database.define('roulette_group_settings', {
         id: { type: 'text', primary: true },
         mute_penalty: { type: 'integer', default: 0 },

package/lib/roulette-actions.d.ts

@@ -1,4 +1,6 @@
+import type { GameMessageLike } from '@zhin.js/game-kit';
 export type RouletteCommandAction = 'help' | 'open' | 'join' | 'start' | 'fire' | 'leave' | 'cancel' | 'status' | 'penalty-on' | 'penalty-off' | 'penalty-status';
 /** Empty input means help; unknown words return null so normal chat is never hijacked. */
 export declare function normalizeRouletteAction(raw: string): RouletteCommandAction | null;
+export declare function getRouletteHelp(message?: Pick<GameMessageLike, 'locale' | 'formatCommand'>): string;
 export declare const ROULETTE_HELP: string;

package/lib/roulette-actions.js

@@ -1,3 +1,4 @@
+import { createMessages } from 'zhin.js/i18n';
 const ACTION_WORDS = {
     help: 'help',
     帮助: 'help',
@@ -35,17 +36,25 @@ export function normalizeRouletteAction(raw) {
         return 'help';
     return ACTION_WORDS[word] ?? ACTION_WORDS[word.toLowerCase()] ?? null;
 }
-export const ROULETTE_HELP = [
-    '🔫 俄罗斯轮盘（2 人起，轮流开枪，中弹者输）',
-    '轮盘 开局 — 创建一局并上桌',
-    '轮盘 加入 — 加入等待中的对局',
-    '轮盘 开始 — 房主开局（弹巢随机装 1 发子弹）',
-    '开枪 / 轮盘 开枪 — 轮到你时扣动扳机',
-    '轮盘 退出 — 等待时离开；对局中离开算认输',
-    '轮盘 取消 — 房主、群主、群管理员或机器人管理员取消本局（不计分）',
-    '轮盘 状态 — 查看当前对局',
-    '轮盘 禁言 / 开启禁言 / 关闭禁言 — 查看或切换本群的禁言惩罚（默认关闭）',
-    '',
-    '规则：按加入顺序轮流开枪；轮到的人超时不开枪判负；幸存者各记 1 胜，输家记 1 负。',
-    '战绩与排行：「战绩」「排行 轮盘」。',
-].join('\n');
+const messages = createMessages({
+    title: { 'zh-CN': '🔫 俄罗斯轮盘（2 人起，轮流开枪，中弹者输）', en: '🔫 Russian Roulette (two or more players, take turns; the player hit loses)' },
+    open: { 'zh-CN': '创建一局并上桌', en: 'Open a lobby and join it' },
+    join: { 'zh-CN': '加入等待中的对局', en: 'Join a waiting lobby' },
+    start: { 'zh-CN': '房主开局（弹巢随机装 1 发子弹）', en: 'Host starts the game (one randomly placed bullet)' },
+    fire: { 'zh-CN': '轮到你时扣动扳机', en: 'Pull the trigger on your turn' },
+    leave: { 'zh-CN': '等待时离开；对局中离开算认输', en: 'Leave the lobby; leaving during play forfeits the game' },
+    cancel: { 'zh-CN': '房主或管理员取消本局（不计分）', en: 'Host or manager cancels the game (no score)' },
+    status: { 'zh-CN': '查看当前对局', en: 'View the current game' },
+    mute: { 'zh-CN': '查看禁言惩罚', en: 'View the mute penalty setting' },
+    'mute-on': { 'zh-CN': '开启本群禁言惩罚', en: 'Enable mute penalties for this group' },
+    'mute-off': { 'zh-CN': '关闭本群禁言惩罚', en: 'Disable mute penalties for this group' },
+    rules: { 'zh-CN': '规则：按加入顺序轮流开枪；轮到的人超时不开枪判负；幸存者各记 1 胜，输家记 1 负。禁言惩罚默认关闭。', en: 'Players take turns in join order. Missing your turn deadline loses the game. Each survivor gets one win; the loser gets one loss. Mute penalties are off by default.' },
+});
+export function getRouletteHelp(message = {}) {
+    const command = message.formatCommand?.('roulette');
+    const actions = ['open', 'join', 'start', 'fire', 'leave', 'cancel', 'status', 'mute', 'mute-on', 'mute-off'];
+    return [messages(message.locale, 'title'),
+        ...(command === undefined ? [] : actions.map(action => `${command} ${action} — ${messages(message.locale, action)}`)),
+        '', messages(message.locale, 'rules')].join('\n');
+}
+export const ROULETTE_HELP = getRouletteHelp();

package/lib/roulette-command.js

@@ -1,6 +1,6 @@
 import { messageFromCommandInput } from '@zhin.js/game-kit';
 import { runRouletteAction } from './game-flow.js';
-import { normalizeRouletteAction, ROULETTE_HELP } from './roulette-actions.js';
+import { normalizeRouletteAction, getRouletteHelp } from './roulette-actions.js';
 import { endpointOf, resolveRouletteFlow, senderRolesOf } from './runtime.js';
 /**
  * Shared entry for the `roulette` command and the `轮盘` alias middleware.
@@ -11,10 +11,10 @@ export async function runRouletteCommand(context, input, rawAction) {
     if (!action)
         return null;
     if (action === 'help')
-        return ROULETTE_HELP;
+        return getRouletteHelp(messageFromCommandInput(input, context));
     const flow = resolveRouletteFlow(context);
     const actor = {
-        message: messageFromCommandInput(input),
+        message: messageFromCommandInput(input, context),
         endpoint: endpointOf(input),
         roles: senderRolesOf(input),
     };

package/lib/runtime.d.ts

@@ -1,3 +1,4 @@
+import type { Locale } from 'zhin.js/i18n';
 import { type Token } from 'zhin.js';
 import type { RouletteFlow } from './game-flow.js';
 import { type AdapterProjectionContext } from './mute-penalty.js';
@@ -6,6 +7,8 @@ import type { EndpointIdentity, RouletteServices } from './session-service.js';
 export declare const rouletteServicesToken: Token<RouletteServices>;
 /** A command, middleware or schedule capability context. */
 export interface RouletteCapabilityContext extends AdapterProjectionContext {
+    readonly locale?: Locale;
+    readonly formatCommand?: (path: string) => string | undefined;
     use<T>(token: Token<T>): T;
     readonly config?: unknown;
 }

package/lib/session-service.js

@@ -17,6 +17,7 @@ export class RouletteSessionService extends VersionedSessionService {
         const state = createLobby(host, tableRules(config));
         return this.createRow({
             id: generateCompactId('rlt_'),
+            locale: message.locale ?? 'zh-CN',
             adapter: String(message.$adapter),
             endpoint: message.$endpoint,
             channel_type: message.$channel.type,

package/lib/view.d.ts

@@ -1,10 +1,13 @@
+import type { GameMessageLike } from '@zhin.js/game-kit';
 import type { RouletteConfig } from './config.js';
 import { type RoulettePlayer, type RouletteState } from './engine.js';
-export declare const ROULETTE_TITLE = "\uD83D\uDD2B \u4FC4\u7F57\u65AF\u8F6E\u76D8";
-export declare function describeLobby(state: RouletteState, config: RouletteConfig): string;
-export declare function describeRoundStart(state: RouletteState, config: RouletteConfig): string;
-export declare function describeTurn(state: RouletteState, config: RouletteConfig): string;
-export declare function describeClick(shooter: RoulettePlayer, state: RouletteState, config: RouletteConfig): string;
-export declare function describeEnding(state: RouletteState): string;
-export declare function describeAbort(state: RouletteState): string;
-export declare function describeStatus(state: RouletteState, config: RouletteConfig): string;
+type Presentation = Pick<GameMessageLike, 'locale' | 'formatCommand'>;
+export declare const ROULETTE_TITLE: string;
+export declare function describeLobby(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
+export declare function describeRoundStart(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
+export declare function describeTurn(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
+export declare function describeClick(shooter: RoulettePlayer, state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
+export declare function describeEnding(state: RouletteState, presentation?: Presentation): string;
+export declare function describeAbort(state: RouletteState, presentation?: Presentation): string;
+export declare function describeStatus(state: RouletteState, config: RouletteConfig, presentation?: Presentation): string;
+export {};

package/lib/view.js

@@ -1,73 +1,78 @@
-import { MIN_ROULETTE_PLAYERS, currentPlayer, loserOf, remainingChambers, survivorsOf, } from './engine.js';
-export const ROULETTE_TITLE = '🔫 俄罗斯轮盘';
-export function describeLobby(state, config) {
-    const host = state.players.find((player) => player.id === state.hostId);
-    const lines = [
-        `${ROULETTE_TITLE} · 等待玩家（${state.players.length}/${config.maxPlayers}）`,
-        `玩家：${listNames(state.players)}`,
-        `发送「轮盘 加入」上桌；${host?.name ?? '房主'} 发送「轮盘 开始」开局（至少 ${MIN_ROULETTE_PLAYERS} 人）。`,
-        `${config.lobbyTimeoutSeconds} 秒内没有开始会自动解散。`,
-    ];
-    return lines.join('\n');
+import { createMessages } from 'zhin.js/i18n';
+import { MIN_ROULETTE_PLAYERS, currentPlayer, loserOf, remainingChambers, survivorsOf } from './engine.js';
+const messages = createMessages({
+    title: { 'zh-CN': '🔫 俄罗斯轮盘', en: '🔫 Russian Roulette' },
+    lobby: { 'zh-CN': '{title} · 等待玩家（{count}/{max}）', en: '{title} · Waiting for players ({count}/{max})' },
+    players: { 'zh-CN': '玩家：{players}', en: 'Players: {players}' },
+    host: { 'zh-CN': '房主', en: 'Host' },
+    joinStart: { 'zh-CN': '发送「{join}」上桌；{host} 发送「{start}」开局（至少 {min} 人）。', en: 'Send “{join}” to join. {host}: send “{start}” to start (at least {min} players).' },
+    lobbyExpiry: { 'zh-CN': '{seconds} 秒内没有开始会自动解散。', en: 'The lobby closes if the game does not start within {seconds} seconds.' },
+    started: { 'zh-CN': '{title} · 开局！{chambers} 个弹巢里装了 1 发子弹，已转好弹巢。', en: '{title} · Started! One bullet in {chambers} chambers. The cylinder has been spun.' },
+    order: { 'zh-CN': '开枪顺序：', en: 'Turn order:' },
+    turn: { 'zh-CN': '👉 轮到 {name}：{instruction}{seconds} 秒内不开枪判负。（剩余 {chambers} 个弹巢）', en: '👉 {name} to play: {instruction}pull the trigger within {seconds} seconds or lose. ({chambers} chambers remaining)' },
+    fire: { 'zh-CN': '发送「{command}」，', en: 'send “{command}”; ' },
+    click: { 'zh-CN': '咔哒……{name} 的这一枪是空膛。', en: 'Click… {name} found an empty chamber.' },
+    survived: { 'zh-CN': '🏆 幸存：{names}（各 +1 胜）', en: '🏆 Survivors: {names} (+1 win each)' },
+    leaderboard: { 'zh-CN': '可在游戏大厅查看本群排行。', en: 'The group leaderboard is available in the game lobby.' },
+    expired: { 'zh-CN': '{title} 长时间没有开始，已自动解散。', en: '{title}: the lobby expired before the game started.' },
+    empty: { 'zh-CN': '{title} 所有人都离开了，已解散。', en: '{title}: everyone left; the lobby is closed.' },
+    aborted: { 'zh-CN': '{title} 已取消，本局不计分。', en: '{title}: cancelled. No scores were recorded.' },
+    status: { 'zh-CN': '{title} · 进行中，已开 {pulls} 枪', en: '{title} · In progress, {pulls} trigger pulls' },
+    timeout: { 'zh-CN': '⌛ {name} 超时没有开枪，判负！', en: '⌛ {name} ran out of time and loses!' },
+    forfeit: { 'zh-CN': '🏳️ {name} 中途离场，判负！', en: '🏳️ {name} left the game and forfeits!' },
+    shot: { 'zh-CN': '💥 砰！{name} 中弹出局（第 {pulls} 枪）。', en: '💥 Bang! {name} is out (trigger pull {pulls}).' },
+    none: { 'zh-CN': '无', en: 'None' },
+});
+export const ROULETTE_TITLE = messages('zh-CN', 'title');
+export function describeLobby(state, config, presentation = {}) {
+    const locale = presentation.locale;
+    const host = state.players.find(player => player.id === state.hostId);
+    const command = presentation.formatCommand?.('roulette');
+    return [messages(locale, 'lobby', { title: messages(locale, 'title'), count: state.players.length, max: config.maxPlayers }),
+        messages(locale, 'players', { players: listNames(state.players, presentation) }),
+        ...(command === undefined ? [] : [messages(locale, 'joinStart', { join: `${command} join`, start: `${command} start`, host: host?.name ?? messages(locale, 'host'), min: MIN_ROULETTE_PLAYERS })]),
+        messages(locale, 'lobbyExpiry', { seconds: config.lobbyTimeoutSeconds }),
+    ].join('\n');
 }
-export function describeRoundStart(state, config) {
-    const order = state.players.map((player, index) => `${index + 1}. ${player.name}`);
-    const lines = [
-        `${ROULETTE_TITLE} · 开局！${state.chamberCount} 个弹巢里装了 1 发子弹，已转好弹巢。`,
-        '开枪顺序：',
-        ...order,
-        describeTurn(state, config),
-    ];
-    return lines.join('\n');
+export function describeRoundStart(state, config, presentation = {}) {
+    return [messages(presentation.locale, 'started', { title: messages(presentation.locale, 'title'), chambers: state.chamberCount }),
+        messages(presentation.locale, 'order'), ...state.players.map((player, index) => `${index + 1}. ${player.name}`),
+        describeTurn(state, config, presentation),
+    ].join('\n');
 }
-export function describeTurn(state, config) {
+export function describeTurn(state, config, presentation = {}) {
     const shooter = currentPlayer(state);
     if (!shooter)
         return '';
-    return `👉 轮到 ${shooter.name}：发送「开枪」，${config.turnTimeoutSeconds} 秒内不开枪判负。`
-        + `（剩余 ${remainingChambers(state)} 个弹巢）`;
+    const command = presentation.formatCommand?.('roulette');
+    return messages(presentation.locale, 'turn', { name: shooter.name, seconds: config.turnTimeoutSeconds,
+        chambers: remainingChambers(state), instruction: command === undefined ? ''
+            : messages(presentation.locale, 'fire', { command: `${command} fire` }) });
 }
-export function describeClick(shooter, state, config) {
-    return [`咔哒……${shooter.name} 的这一枪是空膛。`, describeTurn(state, config)].join('\n');
+export function describeClick(shooter, state, config, presentation = {}) {
+    return [messages(presentation.locale, 'click', { name: shooter.name }), describeTurn(state, config, presentation)].join('\n');
 }
-export function describeEnding(state) {
+export function describeEnding(state, presentation = {}) {
     const loser = loserOf(state);
     if (!loser)
-        return describeAbort(state);
-    const headline = endingHeadline(state, loser);
-    const survivors = survivorsOf(state);
-    return [
-        headline,
-        `🏆 幸存：${listNames(survivors)}（各 +1 胜）`,
-        '发送「排行 轮盘」查看本群排行。',
+        return describeAbort(state, presentation);
+    const key = state.endReason === 'turn-timeout' ? 'timeout' : state.endReason === 'forfeit' ? 'forfeit' : 'shot';
+    return [messages(presentation.locale, key, { name: loser.name, pulls: state.pullsMade }),
+        messages(presentation.locale, 'survived', { names: listNames(survivorsOf(state), presentation) }),
+        messages(presentation.locale, 'leaderboard'),
     ].join('\n');
 }
-export function describeAbort(state) {
-    if (state.endReason === 'lobby-expired')
-        return `${ROULETTE_TITLE} 长时间没有开始，已自动解散。`;
-    if (state.endReason === 'lobby-empty')
-        return `${ROULETTE_TITLE} 所有人都离开了，已解散。`;
-    return `${ROULETTE_TITLE} 已取消，本局不计分。`;
+export function describeAbort(state, presentation = {}) {
+    return messages(presentation.locale, state.endReason === 'lobby-expired' ? 'expired' : state.endReason === 'lobby-empty' ? 'empty' : 'aborted', { title: messages(presentation.locale, 'title') });
 }
-export function describeStatus(state, config) {
+export function describeStatus(state, config, presentation = {}) {
     if (state.phase === 'lobby')
-        return describeLobby(state, config);
-    const lines = [
-        `${ROULETTE_TITLE} · 进行中，已开 ${state.pullsMade} 枪`,
-        `玩家：${listNames(state.players)}`,
-        describeTurn(state, config),
-    ];
-    return lines.join('\n');
-}
-function endingHeadline(state, loser) {
-    if (state.endReason === 'turn-timeout')
-        return `⌛ ${loser.name} 超时没有开枪，判负！`;
-    if (state.endReason === 'forfeit')
-        return `🏳️ ${loser.name} 中途离场，判负！`;
-    return `💥 砰！${loser.name} 中弹出局（第 ${state.pullsMade} 枪）。`;
+        return describeLobby(state, config, presentation);
+    return [messages(presentation.locale, 'status', { title: messages(presentation.locale, 'title'), pulls: state.pullsMade }),
+        messages(presentation.locale, 'players', { players: listNames(state.players, presentation) }),
+        describeTurn(state, config, presentation),
+    ].join('\n');
 }
-function listNames(players) {
-    if (players.length === 0)
-        return '无';
-    return players.map((player) => player.name).join('、');
+function listNames(players, presentation) {
+    return players.length ? players.map(player => player.name).join(presentation.locale === 'en' ? ', ' : '、') : messages(presentation.locale, 'none');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/plugin-roulette",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Zhin.js 俄罗斯轮盘 — 多人轮流开枪，可按群开启禁言惩罚 (Plugin Runtime)",
   "type": "module",
   "main": "./lib/index.js",
@@ -30,15 +30,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@zhin.js/core": "1.1.50",
-    "@zhin.js/game-kit": "1.1.15"
+    "@zhin.js/core": "1.1.52",
+    "@zhin.js/game-kit": "1.1.17"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
-    "@zhin.js/schedule-feature": "1.1.8",
-    "@zhin.js/testing": "1.0.5",
-    "zhin.js": "1.1.15"
+    "@zhin.js/schedule-feature": "1.1.9",
+    "@zhin.js/testing": "1.0.6",
+    "zhin.js": "1.1.17"
   },
   "repository": {
     "type": "git",
@@ -79,10 +79,10 @@
     "plugins": []
   },
   "peerDependencies": {
-    "@zhin.js/command": "^1.1.10",
-    "@zhin.js/middleware": "^1.1.9",
-    "zhin.js": "^1.1.15",
-    "@zhin.js/schedule-feature": "^1.1.8"
+    "@zhin.js/command": "^1.1.11",
+    "@zhin.js/middleware": "^1.1.10",
+    "zhin.js": "^1.1.17",
+    "@zhin.js/schedule-feature": "^1.1.9"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {

package/plugin.js

@@ -17,6 +17,10 @@ export default defineGamePlugin({
         displayName: 'Russian Roulette',
     },
     game: {
+        commandPath: 'roulette',
+        titleI18n: { en: 'Roulette' },
+        descriptionI18n: { en: 'Take turns in a multiplayer roulette game' },
+        quickStartI18n: { en: 'open' },
         id: 'roulette',
         title: '俄罗斯轮盘',
         icon: '🔫',