@zhin.js/plugin-dungeon-expedition 1.1.15 → 1.1.16

package/src/engine.ts

@@ -1,3 +1,4 @@
+import { createMessages, type Locale } from 'zhin.js/i18n';
 import { DeterministicRandom } from '@zhin.js/game-kit';
 
 export const DUNGEON_SCHEMA_VERSION = 1;
@@ -62,6 +63,7 @@ export class DungeonRuleError extends Error {
 export function createDungeonState(
   ownerId: string,
   ownerName: string,
+  locale?: Locale,
 ): DungeonState {
   return {
     schemaVersion: DUNGEON_SCHEMA_VERSION,
@@ -74,7 +76,7 @@ export function createDungeonState(
     turnIndex: 0,
     players: [createPlayer(ownerId, ownerName, true)],
     enemy: null,
-    log: [`${ownerName} 创建了远征队。`],
+    log: [messages(locale, 'text1', { p0: ownerName })],
   };
 }
 
@@ -83,41 +85,42 @@ export function applyDungeonAction(
   actorId: string,
   action: DungeonAction,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase === 'completed') {
-    throw new DungeonRuleError('本次远征已经结束。');
+    throw new DungeonRuleError(messages(locale, 'text2'));
   }
-  if (action.type === 'join') return joinParty(state, actorId, action.name);
+  if (action.type === 'join') return joinParty(state, actorId, action.name, locale);
   const actorIndex = state.players.findIndex((player) => player.id === actorId);
-  if (actorIndex < 0) throw new DungeonRuleError('你还没有加入这支远征队。');
+  if (actorIndex < 0) throw new DungeonRuleError(messages(locale, 'text3'));
   if (action.type === 'abort') {
     if (state.ownerId !== actorId) {
-      throw new DungeonRuleError('只有队长可以结束整支远征。');
+      throw new DungeonRuleError(messages(locale, 'text4'));
     }
     return appendLog({
       ...state,
       phase: 'completed',
       result: 'aborted',
       enemy: null,
-    }, '队长结束了本次远征。');
+    }, messages(locale, 'text5'));
   }
   if (action.type === 'ready') {
     if (state.phase !== 'lobby') {
-      throw new DungeonRuleError('远征已经开始，无法修改准备状态。');
+      throw new DungeonRuleError(messages(locale, 'text6'));
     }
     const players = state.players.map((player, index) =>
       index === actorIndex ? { ...player, ready: !player.ready } : player);
     return appendLog(
       { ...state, players },
-      `${players[actorIndex]?.name ?? actorId}${players[actorIndex]?.ready ? '已准备' : '取消准备'}。`,
+      `${players[actorIndex]?.name ?? actorId}${players[actorIndex]?.ready ? messages(locale, 'text7') : messages(locale, 'text8')}。`,
     );
   }
-  if (action.type === 'start') return startExpedition(state, actorId);
-  assertActorTurn(state, actorId);
-  if (action.type === 'explore') return explore(state, random);
-  if (action.type === 'attack') return attack(state, actorIndex, random);
-  if (action.type === 'defend') return defend(state, actorIndex, random);
-  return drinkPotion(state, actorIndex, random);
+  if (action.type === 'start') return startExpedition(state, actorId, locale);
+  assertActorTurn(state, actorId, locale);
+  if (action.type === 'explore') return explore(state, random, locale);
+  if (action.type === 'attack') return attack(state, actorIndex, random, locale);
+  if (action.type === 'defend') return defend(state, actorIndex, random, locale);
+  return drinkPotion(state, actorIndex, random, locale);
 }
 
 export function activePlayer(state: Readonly<DungeonState>): DungeonPlayer | null {
@@ -156,73 +159,76 @@ function joinParty(
   state: Readonly<DungeonState>,
   actorId: string,
   actorName: string,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase !== 'lobby') {
-    throw new DungeonRuleError('远征已经出发，无法中途加入。');
+    throw new DungeonRuleError(messages(locale, 'text9'));
   }
   if (state.players.some((player) => player.id === actorId)) {
-    throw new DungeonRuleError('你已经在远征队中。');
+    throw new DungeonRuleError(messages(locale, 'text10'));
   }
   if (state.players.length >= MAX_PARTY_SIZE) {
-    throw new DungeonRuleError('远征队已满，最多 4 人。');
+    throw new DungeonRuleError(messages(locale, 'text11'));
   }
   const player = createPlayer(actorId, actorName, false);
   return appendLog(
     { ...state, players: [...state.players, player] },
-    `${player.name} 加入了远征队。`,
+    messages(locale, 'text12', { p0: player.name }),
   );
 }
 
 function startExpedition(
   state: Readonly<DungeonState>,
   actorId: string,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase !== 'lobby') {
-    throw new DungeonRuleError('远征已经开始。');
+    throw new DungeonRuleError(messages(locale, 'text13'));
   }
   if (state.ownerId !== actorId) {
-    throw new DungeonRuleError('只有队长可以带队出发。');
+    throw new DungeonRuleError(messages(locale, 'text14'));
   }
   const waiting = state.players.filter((player) => !player.ready);
   if (waiting.length > 0) {
     throw new DungeonRuleError(
-      `仍有队员未准备：${waiting.map((player) => player.name).join('、')}`,
+      messages(locale, 'text15', { p0: waiting.map((player) => player.name).join('、') }),
     );
   }
-  return appendLog({ ...state, phase: 'exploring' }, '远征队进入了第一层地牢。');
+  return appendLog({ ...state, phase: 'exploring' }, messages(locale, 'text16'));
 }
 
-function assertActorTurn(state: Readonly<DungeonState>, actorId: string): void {
+function assertActorTurn(state: Readonly<DungeonState>, actorId: string, locale?: Locale): void {
   if (state.phase === 'lobby') {
-    throw new DungeonRuleError('请先由队长开始远征。');
+    throw new DungeonRuleError(messages(locale, 'text17'));
   }
   const current = activePlayer(state);
   if (!current || current.id !== actorId) {
-    throw new DungeonRuleError(`现在轮到 ${current?.name ?? '其他队员'} 行动。`);
+    throw new DungeonRuleError(messages(locale, 'text18', { p0: current?.name ?? messages(locale, 'otherPlayer') }));
   }
 }
 
 function explore(
   state: Readonly<DungeonState>,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase !== 'exploring') {
-    throw new DungeonRuleError('战斗尚未结束，无法继续探索。');
+    throw new DungeonRuleError(messages(locale, 'text19'));
   }
   const room = state.room + 1;
   if (room >= BOSS_ROOM) {
-    const enemy = createEnemy(state.floor, true, random);
+    const enemy = createEnemy(state.floor, true, random, locale);
     return appendLog(
       { ...state, room, phase: 'combat', enemy },
-      `守层者 ${enemy.name} 挡住了去路！`,
+      messages(locale, 'text20', { p0: enemy.name }),
     );
   }
   const roll = random.int(100);
   if (roll < 58) {
-    const enemy = createEnemy(state.floor, false, random);
+    const enemy = createEnemy(state.floor, false, random, locale);
     return appendLog(
       { ...state, room, phase: 'combat', enemy },
-      `遭遇了 ${enemy.name}！`,
+      messages(locale, 'text21', { p0: enemy.name }),
     );
   }
   if (roll < 78) {
@@ -236,7 +242,7 @@ function explore(
           gold: player.gold + gold,
         })),
       },
-      `发现宝箱，每位队员获得 ${gold} 金币。`,
+      messages(locale, 'text22', { p0: gold }),
     );
   }
   if (roll < 90) {
@@ -249,7 +255,7 @@ function explore(
           hp: Math.min(player.maxHp, player.hp + 18),
         })),
       },
-      '发现治愈泉，队伍恢复了生命。',
+      messages(locale, 'text23'),
     );
   }
   const damage = random.intInclusive(8, 16);
@@ -261,9 +267,9 @@ function explore(
       : player);
   const trapped = advanceAfterRoom(
     { ...state, room, players },
-    `${target?.name ?? '队员'} 触发陷阱，受到 ${damage} 点伤害。`,
+    messages(locale, 'text24', { p0: target?.name ?? messages(locale, 'player'), p1: damage }),
   );
-  const resolved = finishIfDefeated(trapped);
+  const resolved = finishIfDefeated(trapped, locale);
   if (resolved.phase === 'completed' || (players[targetIndex]?.hp ?? 0) > 0) {
     return resolved;
   }
@@ -274,49 +280,52 @@ function attack(
   state: Readonly<DungeonState>,
   actorIndex: number,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase !== 'combat' || !state.enemy) {
-    throw new DungeonRuleError('当前没有可以攻击的敌人。');
+    throw new DungeonRuleError(messages(locale, 'text25'));
   }
   const actor = state.players[actorIndex];
-  if (!actor || actor.hp <= 0) throw new DungeonRuleError('倒下的队员无法行动。');
+  if (!actor || actor.hp <= 0) throw new DungeonRuleError(messages(locale, 'text26'));
   const damage = random.intInclusive(12, 22);
   const enemy = { ...state.enemy, hp: Math.max(0, state.enemy.hp - damage) };
   let next = appendLog(
     { ...state, enemy },
-    `${actor.name} 对 ${enemy.name} 造成 ${damage} 点伤害。`,
+    messages(locale, 'text27', { p0: actor.name, p1: enemy.name, p2: damage }),
   );
-  if (enemy.hp <= 0) return defeatEnemy(next, random);
-  next = enemyTurn(next, actorIndex, random);
-  return advanceTurn(finishIfDefeated(next));
+  if (enemy.hp <= 0) return defeatEnemy(next, random, locale);
+  next = enemyTurn(next, actorIndex, random, locale);
+  return advanceTurn(finishIfDefeated(next, locale));
 }
 
 function defend(
   state: Readonly<DungeonState>,
   actorIndex: number,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   if (state.phase !== 'combat' || !state.enemy) {
-    throw new DungeonRuleError('当前不需要防御。');
+    throw new DungeonRuleError(messages(locale, 'text28'));
   }
   const actor = state.players[actorIndex];
-  if (!actor || actor.hp <= 0) throw new DungeonRuleError('倒下的队员无法行动。');
+  if (!actor || actor.hp <= 0) throw new DungeonRuleError(messages(locale, 'text26'));
   const players = state.players.map((player, index) =>
     index === actorIndex ? { ...player, guard: 8 } : player);
-  let next = appendLog({ ...state, players }, `${actor.name} 架起了盾牌。`);
-  next = enemyTurn(next, actorIndex, random);
-  return advanceTurn(finishIfDefeated(next));
+  let next = appendLog({ ...state, players }, messages(locale, 'text29', { p0: actor.name }));
+  next = enemyTurn(next, actorIndex, random, locale);
+  return advanceTurn(finishIfDefeated(next, locale));
 }
 
 function drinkPotion(
   state: Readonly<DungeonState>,
   actorIndex: number,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   const actor = state.players[actorIndex];
-  if (!actor || actor.hp <= 0) throw new DungeonRuleError('倒下的队员无法行动。');
-  if (actor.potions <= 0) throw new DungeonRuleError('你的药水已经用完了。');
-  if (actor.hp >= actor.maxHp) throw new DungeonRuleError('你的生命值已经满了。');
+  if (!actor || actor.hp <= 0) throw new DungeonRuleError(messages(locale, 'text26'));
+  if (actor.potions <= 0) throw new DungeonRuleError(messages(locale, 'text30'));
+  if (actor.hp >= actor.maxHp) throw new DungeonRuleError(messages(locale, 'text31'));
   const players = state.players.map((player, index) =>
     index === actorIndex
       ? {
@@ -325,10 +334,10 @@ function drinkPotion(
           potions: player.potions - 1,
         }
       : player);
-  let next = appendLog({ ...state, players }, `${actor.name} 使用药水恢复生命。`);
+  let next = appendLog({ ...state, players }, messages(locale, 'text32', { p0: actor.name }));
   if (state.phase === 'combat') {
-    next = enemyTurn(next, actorIndex, random);
-    return advanceTurn(finishIfDefeated(next));
+    next = enemyTurn(next, actorIndex, random, locale);
+    return advanceTurn(finishIfDefeated(next, locale));
   }
   return next;
 }
@@ -337,6 +346,7 @@ function enemyTurn(
   state: Readonly<DungeonState>,
   targetIndex: number,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   const enemy = state.enemy;
   const target = state.players[targetIndex];
@@ -352,13 +362,14 @@ function enemyTurn(
       : player);
   return appendLog(
     { ...state, players },
-    `${enemy.name} 反击 ${target.name}，造成 ${damage} 点伤害。`,
+    messages(locale, 'text33', { p0: enemy.name, p1: target.name, p2: damage }),
   );
 }
 
 function defeatEnemy(
   state: Readonly<DungeonState>,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonState {
   const enemy = state.enemy;
   if (!enemy) return state;
@@ -377,7 +388,7 @@ function defeatEnemy(
       phase: 'completed',
       result: 'victory',
       roomsCleared: state.roomsCleared + 1,
-    }, `击败最终守层者，每人获得 ${gold} 金币。远征胜利！`);
+    }, messages(locale, 'text34', { p0: gold }));
   }
   if (enemy.boss) {
     return appendLog({
@@ -386,11 +397,11 @@ function defeatEnemy(
       floor: state.floor + 1,
       room: 0,
       roomsCleared: state.roomsCleared + 1,
-    }, `击败守层者，每人获得 ${gold} 金币。队伍进入下一层。`);
+    }, messages(locale, 'text35', { p0: gold }));
   }
   return advanceAfterRoom(
     { ...rewarded, phase: 'exploring' },
-    `击败 ${enemy.name}，每人获得 ${gold} 金币。`,
+    messages(locale, 'text36', { p0: enemy.name, p1: gold }),
   );
 }
 
@@ -398,10 +409,11 @@ function createEnemy(
   floor: number,
   boss: boolean,
   random: DeterministicRandom,
+  locale?: Locale,
 ): DungeonEnemy {
   const names = boss
-    ? ['石像守卫', '深渊术士', '远古龙影']
-    : ['洞穴史莱姆', '骷髅巡卫', '暗影猎手', '失控魔像'];
+    ? [messages(locale, 'text37'), messages(locale, 'text38'), messages(locale, 'text39')]
+    : [messages(locale, 'text40'), messages(locale, 'text41'), messages(locale, 'text42'), messages(locale, 'text43')];
   const name = boss
     ? names[Math.min(names.length - 1, floor - 1)] as string
     : random.item(names);
@@ -445,14 +457,14 @@ function nextLivingIndex(
   return 0;
 }
 
-function finishIfDefeated(state: Readonly<DungeonState>): DungeonState {
+function finishIfDefeated(state: Readonly<DungeonState>, locale?: Locale): DungeonState {
   if (state.players.some((player) => player.hp > 0)) return state as DungeonState;
   return appendLog({
     ...state,
     phase: 'completed',
     result: 'defeat',
     enemy: null,
-  }, '远征队全员倒下，本次远征失败。');
+  }, messages(locale, 'text44'));
 }
 
 function appendLog(
@@ -464,3 +476,52 @@ function appendLog(
     log: [...state.log, message].slice(-8),
   } as DungeonState;
 }
+
+const messages = createMessages({
+  otherPlayer: { 'zh-CN': '其他队员', en: 'another player' },
+  player: { 'zh-CN': '队员', en: 'A player' },
+  text1: { 'zh-CN': "{p0} 创建了远征队。", en: "{p0} created the expedition party." },
+  text2: { 'zh-CN': "本次远征已经结束。", en: "This expedition has ended." },
+  text3: { 'zh-CN': "你还没有加入这支远征队。", en: "You have not joined this expedition." },
+  text4: { 'zh-CN': "只有队长可以结束整支远征。", en: "Only the leader may end the expedition." },
+  text5: { 'zh-CN': "队长结束了本次远征。", en: "The leader ended the expedition." },
+  text6: { 'zh-CN': "远征已经开始，无法修改准备状态。", en: "The expedition has started; readiness can no longer be changed." },
+  text7: { 'zh-CN': "已准备", en: " is ready" },
+  text8: { 'zh-CN': "取消准备", en: " is no longer ready" },
+  text9: { 'zh-CN': "远征已经出发，无法中途加入。", en: "The expedition has started; you cannot join mid-game." },
+  text10: { 'zh-CN': "你已经在远征队中。", en: "You are already in the party." },
+  text11: { 'zh-CN': "远征队已满，最多 4 人。", en: "The party is full (maximum four players)." },
+  text12: { 'zh-CN': "{p0} 加入了远征队。", en: "{p0} joined the party." },
+  text13: { 'zh-CN': "远征已经开始。", en: "The expedition has already started." },
+  text14: { 'zh-CN': "只有队长可以带队出发。", en: "Only the leader may start the expedition." },
+  text15: { 'zh-CN': "仍有队员未准备：{p0}", en: "Players not ready: {p0}" },
+  text16: { 'zh-CN': "远征队进入了第一层地牢。", en: "The party entered the first floor." },
+  text17: { 'zh-CN': "请先由队长开始远征。", en: "Ask the leader to start the expedition first." },
+  text18: { 'zh-CN': "现在轮到 {p0} 行动。", en: "It is {p0}’s turn." },
+  text19: { 'zh-CN': "战斗尚未结束，无法继续探索。", en: "Finish the battle before exploring further." },
+  text20: { 'zh-CN': "守层者 {p0} 挡住了去路！", en: "Floor guardian {p0} blocks the way!" },
+  text21: { 'zh-CN': "遭遇了 {p0}！", en: "Encountered {p0}!" },
+  text22: { 'zh-CN': "发现宝箱，每位队员获得 {p0} 金币。", en: "A treasure chest! Each player gains {p0} gold." },
+  text23: { 'zh-CN': "发现治愈泉，队伍恢复了生命。", en: "A healing spring restores the party’s health." },
+  text24: { 'zh-CN': "{p0} 触发陷阱，受到 {p1} 点伤害。", en: "{p0} triggered a trap and took {p1} damage." },
+  text25: { 'zh-CN': "当前没有可以攻击的敌人。", en: "There is no enemy to attack." },
+  text26: { 'zh-CN': "倒下的队员无法行动。", en: "Defeated players cannot act." },
+  text27: { 'zh-CN': "{p0} 对 {p1} 造成 {p2} 点伤害。", en: "{p0} dealt {p2} damage to {p1}." },
+  text28: { 'zh-CN': "当前不需要防御。", en: "There is no need to defend right now." },
+  text29: { 'zh-CN': "{p0} 架起了盾牌。", en: "{p0} raised a shield." },
+  text30: { 'zh-CN': "你的药水已经用完了。", en: "You have no potions left." },
+  text31: { 'zh-CN': "你的生命值已经满了。", en: "Your health is already full." },
+  text32: { 'zh-CN': "{p0} 使用药水恢复生命。", en: "{p0} used a potion to restore health." },
+  text33: { 'zh-CN': "{p0} 反击 {p1}，造成 {p2} 点伤害。", en: "{p0} counterattacked {p1} for {p2} damage." },
+  text34: { 'zh-CN': "击败最终守层者，每人获得 {p0} 金币。远征胜利！", en: "The final guardian is defeated! Each player gains {p0} gold. Expedition victory!" },
+  text35: { 'zh-CN': "击败守层者，每人获得 {p0} 金币。队伍进入下一层。", en: "The floor guardian is defeated! Each player gains {p0} gold. The party advances to the next floor." },
+  text36: { 'zh-CN': "击败 {p0}，每人获得 {p1} 金币。", en: "Defeated {p0}! Each player gains {p1} gold." },
+  text37: { 'zh-CN': "石像守卫", en: "Stone Guardian" },
+  text38: { 'zh-CN': "深渊术士", en: "Abyss Warlock" },
+  text39: { 'zh-CN': "远古龙影", en: "Ancient Dragon Shade" },
+  text40: { 'zh-CN': "洞穴史莱姆", en: "Cave Slime" },
+  text41: { 'zh-CN': "骷髅巡卫", en: "Skeleton Patrol" },
+  text42: { 'zh-CN': "暗影猎手", en: "Shadow Hunter" },
+  text43: { 'zh-CN': "失控魔像", en: "Rampaging Golem" },
+  text44: { 'zh-CN': "远征队全员倒下，本次远征失败。", en: "The entire party fell. The expedition failed." },
+});

package/src/game-flow.ts

@@ -1,3 +1,4 @@
+import { createMessages, resolveLocale } from 'zhin.js/i18n';
 import {
   GameSessionConflictError,
   SessionRevisionConflictError,
@@ -29,7 +30,7 @@ export async function startDungeon(
     const session = await service.createSession(message);
     return buildDungeonView(session, stateFromSession(session), message.$channel.type);
   } catch (error) {
-    if (error instanceof GameSessionConflictError) return error.message;
+    if (error instanceof GameSessionConflictError) return error.format(message.locale);
     throw error;
   }
 }
@@ -38,8 +39,9 @@ export async function continueDungeon(
   service: SessionService,
   message: GameMessageLike,
 ): Promise<GameReply> {
+  const locale = resolveLocale(message.locale);
   const session = await service.getActiveByChannel(channelKey(message));
-  if (!session) return '当前频道没有进行中的地牢远征。发送「地牢 开始」创建队伍。';
+  if (!session) return messages(locale, 'text1');
   return buildDungeonView(session, stateFromSession(session), message.$channel.type);
 }
 
@@ -49,19 +51,21 @@ export async function handleDungeonChoice(
   sessionToken: string,
   choiceId: string,
 ): Promise<GameReply> {
+  let locale = resolveLocale(message.locale);
   const token = parseDungeonSessionToken(sessionToken);
-  if (!token) return '无效的地牢操作。';
+  if (!token) return messages(locale, 'text2');
   const session = await service.getById(token.sessionId);
   if (!session || session.channel_key !== channelKey(message)) {
-    return '远征不存在，或不属于当前频道。';
+    return messages(locale, 'text3');
   }
+  locale = resolveLocale(session.locale);
   if (choiceId === 'restart') {
-    if (session.status === 'active') return '当前远征尚未结束。';
-    if (session.owner_id !== message.$sender.id) return '只有原队长可以重新创建远征。';
+    if (session.status === 'active') return messages(locale, 'text4');
+    if (session.owner_id !== message.$sender.id) return messages(locale, 'text5');
     return startDungeon(service, message);
   }
   const action = actionFromChoice(choiceId, message);
-  if (!action) return '未知的地牢操作。';
+  if (!action) return messages(locale, 'text6');
   try {
     const result = await service.performAction({
       sessionId: session.id,
@@ -77,21 +81,19 @@ export async function handleDungeonChoice(
       message.$channel.type,
     );
   } catch (error) {
-    if (error instanceof DungeonRuleError
-      || error instanceof GameSessionConflictError) {
-      return error.message;
-    }
+    if (error instanceof DungeonRuleError) return error.message;
+    if (error instanceof GameSessionConflictError) return error.format(locale);
     if (error instanceof SessionRevisionConflictError) {
       const latest = await service.getById(session.id);
-      if (!latest) return '远征状态已变化，请重新打开当前界面。';
+      if (!latest) return messages(locale, 'text7');
       const view = buildDungeonView(
         latest,
         stateFromSession(latest),
         message.$channel.type,
       );
       return Array.isArray(view)
-        ? ['操作来自旧回合，已为你刷新最新状态。', ...view]
-        : ['操作来自旧回合，已为你刷新最新状态。', view];
+        ? [messages(locale, 'text8'), ...view]
+        : [messages(locale, 'text8'), view];
     }
     throw error;
   }
@@ -124,3 +126,14 @@ function actionFromChoice(
   if (choiceId === 'abort') return { type: 'abort' };
   return null;
 }
+
+const messages = createMessages({
+  text1: { 'zh-CN': "当前频道没有进行中的地牢远征。", en: "There is no active dungeon expedition in this channel." },
+  text2: { 'zh-CN': "无效的地牢操作。", en: "Invalid dungeon action." },
+  text3: { 'zh-CN': "远征不存在，或不属于当前频道。", en: "The expedition does not exist or belongs to another channel." },
+  text4: { 'zh-CN': "当前远征尚未结束。", en: "The current expedition has not ended." },
+  text5: { 'zh-CN': "只有原队长可以重新创建远征。", en: "Only the original leader may restart the expedition." },
+  text6: { 'zh-CN': "未知的地牢操作。", en: "Unknown dungeon action." },
+  text7: { 'zh-CN': "远征状态已变化，请重新打开当前界面。", en: "The expedition state changed. Reopen its current view." },
+  text8: { 'zh-CN': "操作来自旧回合，已为你刷新最新状态。", en: "This action was from an earlier turn. The latest state is shown below." },
+});

package/src/models.ts

@@ -6,6 +6,7 @@ declare module '@zhin.js/core' {
   interface Models {
     dungeon_sessions: {
       id: string;
+      locale?: 'zh-CN' | 'en' | null;
       adapter: string;
       endpoint: string;
       channel_type: string;
@@ -32,11 +33,12 @@ export type DungeonSessionRow = Models['dungeon_sessions'];
 
 export 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 {
   database.define('dungeon_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 },
@@ -55,5 +57,5 @@ export function defineHostTables(
     status: { type: 'text', default: 'active' },
     updated_at: { type: 'bigint', default: 0 },
     created_at: { type: 'bigint', default: 0 },
-  });
+  }, { addColumns: ['locale'] });
 }

package/src/session-service.ts

@@ -47,10 +47,11 @@ export class SessionService extends VersionedSessionService<DungeonSessionRow> {
     const now = Date.now();
     const id = generateCompactId('dng_');
     const ownerName = message.$sender.name?.trim() || message.$sender.id;
-    const state = createDungeonState(message.$sender.id, ownerName);
+    const state = createDungeonState(message.$sender.id, ownerName, message.locale);
     const random = DeterministicRandom.fromSeed(seed ?? id);
     return this.createRow({
       id,
+      locale: message.locale ?? 'zh-CN',
       adapter: String(message.$adapter),
       endpoint: message.$endpoint,
       channel_type: message.$channel.type,
@@ -113,6 +114,7 @@ export class SessionService extends VersionedSessionService<DungeonSessionRow> {
           options.actorId,
           options.action,
           random,
+          session.locale ?? undefined,
         );
         return {
           state_json: JSON.stringify(next),