koishi-plugin-game-mini 0.2.3 → 0.2.5

package/lib/index.js

@@ -14,193 +14,72 @@ exports.name = 'game-mini';
 exports.using = ['i18n'];
 exports.inject = ['console'];
 exports.Config = koishi_1.Schema.object({
-    enableNumberGuess: koishi_1.Schema.boolean().default(true)
-        .description('启用猜数字游戏')
-        .i18n({ 'zh-CN': '启用猜数字游戏' }),
-    enableWzHero: koishi_1.Schema.boolean().default(true)
-        .description('启用王者英雄猜谜游戏')
-        .i18n({ 'zh-CN': '启用王者英雄猜谜游戏' }),
-    enableChengyuImage: koishi_1.Schema.boolean().default(true)
-        .description('启用看图猜成语游戏')
-        .i18n({ 'zh-CN': '启用看图猜成语游戏' }),
-    enableChengyuJielong: koishi_1.Schema.boolean().default(true)
-        .description('启用成语接龙游戏')
-        .i18n({ 'zh-CN': '启用成语接龙游戏' }),
-    enableDice: koishi_1.Schema.boolean().default(true)
-        .description('启用掷骰子比大小游戏')
-        .i18n({ 'zh-CN': '启用掷骰子比大小游戏' }),
-    enableRps: koishi_1.Schema.boolean().default(true)
-        .description('启用石头剪刀布游戏')
-        .i18n({ 'zh-CN': '启用石头剪刀布游戏' }),
-    enableCalc24: koishi_1.Schema.boolean().default(true)
-        .description('启用算24点游戏')
-        .i18n({ 'zh-CN': '启用算24点游戏' }),
-    enablePasswordLock: koishi_1.Schema.boolean().default(true)
-        .description('启用密码锁破解游戏')
-        .i18n({ 'zh-CN': '启用密码锁破解游戏' }),
-    enablePrivateGame: koishi_1.Schema.boolean().default(true)
-        .description('允许私聊玩游戏')
-        .i18n({ 'zh-CN': '允许私聊玩游戏' }),
-    autoPlayDelay: koishi_1.Schema.number().min(0).default(10)
-        .description('机器人自动操作延迟（秒）')
-        .i18n({ 'zh-CN': '机器人自动操作延迟（秒）' }),
-    autoPlayMaxCount: koishi_1.Schema.number().min(1).default(5)
-        .description('机器人最大自动操作次数')
-        .i18n({ 'zh-CN': '机器人最大自动操作次数' }),
-    autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30)
-        .description('游戏无操作自动停止时间（秒）')
-        .i18n({ 'zh-CN': '游戏无操作自动停止时间（秒）' }),
+    enableNumberGuess: koishi_1.Schema.boolean().default(true).description('启用猜数字游戏'),
+    enableWzHero: koishi_1.Schema.boolean().default(true).description('启用王者英雄猜谜游戏'),
+    enableChengyuImage: koishi_1.Schema.boolean().default(true).description('启用看图猜成语游戏'),
+    enableChengyuJielong: koishi_1.Schema.boolean().default(true).description('启用成语接龙游戏'),
+    enableCalc24: koishi_1.Schema.boolean().default(true).description('启用算24点游戏'),
+    enablePasswordLock: koishi_1.Schema.boolean().default(true).description('启用密码锁破解游戏'),
+    enablePrivateGame: koishi_1.Schema.boolean().default(true).description('允许私聊玩游戏'),
     guessNumber: koishi_1.Schema.object({
-        min: koishi_1.Schema.number().min(0).default(0)
-            .description('猜数字最小值')
-            .i18n({ 'zh-CN': '猜数字最小值' }),
-        max: koishi_1.Schema.number().min(1).default(100)
-            .description('猜数字最大值')
-            .i18n({ 'zh-CN': '猜数字最大值' }),
-        botParticipateInGroup: koishi_1.Schema.boolean().default(true)
-            .description('群聊中机器人参与猜数字')
-            .i18n({ 'zh-CN': '群聊中机器人参与猜数字' }),
-        totalRounds: koishi_1.Schema.number().min(1).default(10)
-            .description('猜数字总回合数')
-            .i18n({ 'zh-CN': '猜数字总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('猜数字显示排行榜')
-            .i18n({ 'zh-CN': '猜数字显示排行榜' }),
-    }).description('猜数字游戏配置')
-        .i18n({ 'zh-CN': '猜数字游戏配置' }),
+        min: koishi_1.Schema.number().min(0).default(0).description('猜数字最小值'),
+        max: koishi_1.Schema.number().min(1).default(100).description('猜数字最大值'),
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中机器人参与猜数字'),
+        totalRounds: koishi_1.Schema.number().min(1).default(10).description('猜数字总回合数'),
+        showRank: koishi_1.Schema.boolean().default(true).description('猜数字显示排行榜'),
+        autoPlayDelay: koishi_1.Schema.number().min(0).default(10).description('机器人自动操作延迟（秒）'),
+        autoPlayMaxCount: koishi_1.Schema.number().min(1).default(5).description('机器人最大自动操作次数'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('猜数字游戏配置'),
     wzHero: koishi_1.Schema.object({
-        totalRounds: koishi_1.Schema.number().min(1).default(10)
-            .description('王者英雄猜谜总回合数')
-            .i18n({ 'zh-CN': '王者英雄猜谜总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('王者英雄猜谜显示排行榜')
-            .i18n({ 'zh-CN': '王者英雄猜谜显示排行榜' }),
-    }).description('王者英雄猜谜游戏配置')
-        .i18n({ 'zh-CN': '王者英雄猜谜游戏配置' }),
+        totalRounds: koishi_1.Schema.number().min(1).default(10).description('王者英雄猜谜总回合数'),
+        showRank: koishi_1.Schema.boolean().default(true).description('王者英雄猜谜显示排行榜'),
+        defaultDifficulty: koishi_1.Schema.union(['简单', '中等', '困难']).default('简单').description('默认难度'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('王者英雄猜谜游戏配置'),
     chengyuImage: koishi_1.Schema.object({
-        totalRounds: koishi_1.Schema.number().min(1).default(10)
-            .description('看图猜成语总回合数')
-            .i18n({ 'zh-CN': '看图猜成语总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('看图猜成语显示排行榜')
-            .i18n({ 'zh-CN': '看图猜成语显示排行榜' }),
-    }).description('看图猜成语游戏配置')
-        .i18n({ 'zh-CN': '看图猜成语游戏配置' }),
+        totalRounds: koishi_1.Schema.number().min(1).default(10).description('看图猜成语总回合数'),
+        showRank: koishi_1.Schema.boolean().default(true).description('看图猜成语显示排行榜'),
+        defaultHintLevel: koishi_1.Schema.union([1, 2, 3, 4, 5]).default(1).description('默认提示级别(1-5)'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('看图猜成语游戏配置'),
     chengyuJielong: koishi_1.Schema.object({
-        botParticipateInGroup: koishi_1.Schema.boolean().default(true)
-            .description('群聊中机器人参与成语接龙')
-            .i18n({ 'zh-CN': '群聊中机器人参与成语接龙' }),
-        totalRounds: koishi_1.Schema.number().min(1).default(10)
-            .description('成语接龙总回合数')
-            .i18n({ 'zh-CN': '成语接龙总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('成语接龙显示排行榜')
-            .i18n({ 'zh-CN': '成语接龙显示排行榜' }),
-    }).description('成语接龙游戏配置')
-        .i18n({ 'zh-CN': '成语接龙游戏配置' }),
-    dice: koishi_1.Schema.object({
-        totalRounds: koishi_1.Schema.number().min(1).default(5)
-            .description('掷骰子总回合数')
-            .i18n({ 'zh-CN': '掷骰子总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('掷骰子显示排行榜')
-            .i18n({ 'zh-CN': '掷骰子显示排行榜' }),
-        botParticipate: koishi_1.Schema.boolean().default(true)
-            .description('机器人参与掷骰子')
-            .i18n({ 'zh-CN': '机器人参与掷骰子' }),
-    }).description('掷骰子比大小游戏配置')
-        .i18n({ 'zh-CN': '掷骰子比大小游戏配置' }),
-    rps: koishi_1.Schema.object({
-        totalRounds: koishi_1.Schema.number().min(1).default(5)
-            .description('石头剪刀布总回合数')
-            .i18n({ 'zh-CN': '石头剪刀布总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('石头剪刀布显示排行榜')
-            .i18n({ 'zh-CN': '石头剪刀布显示排行榜' }),
-        botParticipate: koishi_1.Schema.boolean().default(true)
-            .description('机器人参与石头剪刀布')
-            .i18n({ 'zh-CN': '机器人参与石头剪刀布' }),
-    }).description('石头剪刀布游戏配置')
-        .i18n({ 'zh-CN': '石头剪刀布游戏配置' }),
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中机器人参与成语接龙'),
+        totalRounds: koishi_1.Schema.number().min(1).default(10).description('成语接龙总回合数'),
+        showRank: koishi_1.Schema.boolean().default(true).description('成语接龙显示排行榜'),
+        autoPlayDelay: koishi_1.Schema.number().min(0).default(10).description('机器人自动操作延迟（秒）'),
+        autoPlayMaxCount: koishi_1.Schema.number().min(1).default(5).description('机器人最大自动操作次数'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('成语接龙游戏配置'),
     calc24: koishi_1.Schema.object({
-        totalRounds: koishi_1.Schema.number().min(1).default(5)
-            .description('算24点总回合数')
-            .i18n({ 'zh-CN': '算24点总回合数' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('算24点显示排行榜')
-            .i18n({ 'zh-CN': '算24点显示排行榜' }),
-        numberRange: koishi_1.Schema.array(koishi_1.Schema.number()).default([1, 13])
-            .description('算24点数字范围 [最小值, 最大值]')
-            .i18n({ 'zh-CN': '算24点数字范围 [最小值, 最大值]' }),
-    }).description('算24点游戏配置')
-        .i18n({ 'zh-CN': '算24点游戏配置' }),
+        totalRounds: koishi_1.Schema.number().min(1).default(5).description('算24点总回合数'),
+        showRank: koishi_1.Schema.boolean().default(true).description('算24点显示排行榜'),
+        defaultDifficulty: koishi_1.Schema.union(['简单', '中等', '困难']).default('中等').description('默认难度'),
+        difficultyLevels: koishi_1.Schema.object({
+            easy: koishi_1.Schema.object({
+                min: koishi_1.Schema.number().default(1).description('最小值'),
+                max: koishi_1.Schema.number().default(8).description('最大值'),
+            }).description('简单难度'),
+            medium: koishi_1.Schema.object({
+                min: koishi_1.Schema.number().default(1).description('最小值'),
+                max: koishi_1.Schema.number().default(10).description('最大值'),
+            }).description('中等难度'),
+            hard: koishi_1.Schema.object({
+                min: koishi_1.Schema.number().default(1).description('最小值'),
+                max: koishi_1.Schema.number().default(13).description('最大值'),
+            }).description('困难难度'),
+        }).description('难度等级配置'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('算24点游戏配置'),
     passwordLock: koishi_1.Schema.object({
-        maxGuessTimes: koishi_1.Schema.number().min(1).default(10)
-            .description('密码锁最大猜测次数')
-            .i18n({ 'zh-CN': '密码锁最大猜测次数' }),
-        showHint: koishi_1.Schema.boolean().default(true)
-            .description('密码锁显示提示')
-            .i18n({ 'zh-CN': '密码锁显示提示' }),
-        showRank: koishi_1.Schema.boolean().default(true)
-            .description('密码锁显示排行榜')
-            .i18n({ 'zh-CN': '密码锁显示排行榜' }),
-    }).description('密码锁破解游戏配置')
-        .i18n({ 'zh-CN': '密码锁破解游戏配置' }),
+        maxGuessTimes: koishi_1.Schema.number().min(1).default(10).description('密码锁最大猜测次数'),
+        showHint: koishi_1.Schema.boolean().default(true).description('密码锁显示提示'),
+        showRank: koishi_1.Schema.boolean().default(true).description('密码锁显示排行榜'),
+        autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30).description('游戏无操作自动停止时间（秒）'),
+    }).description('密码锁破解游戏配置'),
     apiConfig: koishi_1.Schema.object({
-        timeout: koishi_1.Schema.number().default(5000)
-            .description('API请求超时时间（毫秒）')
-            .i18n({ 'zh-CN': 'API请求超时时间（毫秒）' }),
-    }).description('API接口配置')
-        .i18n({ 'zh-CN': 'API接口配置' }),
-}).i18n({
-    'zh-CN': {
-        'enableNumberGuess': '启用猜数字游戏',
-        'enableWzHero': '启用王者英雄猜谜游戏',
-        'enableChengyuImage': '启用看图猜成语游戏',
-        'enableChengyuJielong': '启用成语接龙游戏',
-        'enableDice': '启用掷骰子比大小游戏',
-        'enableRps': '启用石头剪刀布游戏',
-        'enableCalc24': '启用算24点游戏',
-        'enablePasswordLock': '启用密码锁破解游戏',
-        'enablePrivateGame': '允许私聊玩游戏',
-        'autoPlayDelay': '机器人自动操作延迟（秒）',
-        'autoPlayMaxCount': '机器人最大自动操作次数',
-        'autoStopInactiveTime': '游戏无操作自动停止时间（秒）',
-        'guessNumber': '猜数字游戏配置',
-        'guessNumber.min': '猜数字最小值',
-        'guessNumber.max': '猜数字最大值',
-        'guessNumber.botParticipateInGroup': '群聊中机器人参与猜数字',
-        'guessNumber.totalRounds': '猜数字总回合数',
-        'guessNumber.showRank': '猜数字显示排行榜',
-        'wzHero': '王者英雄猜谜配置',
-        'wzHero.totalRounds': '王者英雄猜谜总回合数',
-        'wzHero.showRank': '王者英雄猜谜显示排行榜',
-        'chengyuImage': '看图猜成语配置',
-        'chengyuImage.totalRounds': '看图猜成语总回合数',
-        'chengyuImage.showRank': '看图猜成语显示排行榜',
-        'chengyuJielong': '成语接龙配置',
-        'chengyuJielong.botParticipateInGroup': '群聊中机器人参与成语接龙',
-        'chengyuJielong.totalRounds': '成语接龙总回合数',
-        'chengyuJielong.showRank': '成语接龙显示排行榜',
-        'dice': '掷骰子比大小配置',
-        'dice.totalRounds': '掷骰子总回合数',
-        'dice.showRank': '掷骰子显示排行榜',
-        'dice.botParticipate': '机器人参与掷骰子',
-        'rps': '石头剪刀布配置',
-        'rps.totalRounds': '石头剪刀布总回合数',
-        'rps.showRank': '石头剪刀布显示排行榜',
-        'rps.botParticipate': '机器人参与石头剪刀布',
-        'calc24': '算24点配置',
-        'calc24.totalRounds': '算24点总回合数',
-        'calc24.showRank': '算24点显示排行榜',
-        'calc24.numberRange': '算24点数字范围',
-        'passwordLock': '密码锁破解配置',
-        'passwordLock.maxGuessTimes': '密码锁最大猜测次数',
-        'passwordLock.showHint': '密码锁显示提示',
-        'passwordLock.showRank': '密码锁显示排行榜',
-        'apiConfig': 'API接口配置',
-        'apiConfig.timeout': '请求超时时间(毫秒)'
-    }
+        timeout: koishi_1.Schema.number().default(5000).description('API请求超时时间（毫秒）'),
+    }).description('API接口配置'),
 });
 const logger = new koishi_1.Logger('game-mini');
 const gameStates = new Map();
@@ -229,10 +108,6 @@ const checkGameRunning = (s, t) => {
         return true;
     if (t !== 'chengyuJielong' && s.chengyuJielong.started)
         return true;
-    if (t !== 'dice' && s.dice.started)
-        return true;
-    if (t !== 'rps' && s.rps.started)
-        return true;
     if (t !== 'calc24' && s.calc24.started)
         return true;
     if (t !== 'passwordLock' && s.passwordLock.started)
@@ -242,18 +117,16 @@ const checkGameRunning = (s, t) => {
 const clearGameTimer = (state) => {
     if (state.stopTimer)
         clearTimeout(state.stopTimer);
+    if (state.autoPlayTimer)
+        clearTimeout(state.autoPlayTimer);
 };
 const clearAllTimers = (st) => {
     clearGameTimer(st.guessNumber);
     clearGameTimer(st.wzHero);
     clearGameTimer(st.chengyuImage);
     clearGameTimer(st.chengyuJielong);
-    clearGameTimer(st.dice);
-    clearGameTimer(st.rps);
     clearGameTimer(st.calc24);
     clearGameTimer(st.passwordLock);
-    if (st.chengyuJielong.autoPlayTimer)
-        clearTimeout(st.chengyuJielong.autoPlayTimer);
 };
 const initState = (key, c) => {
     const s = {
@@ -274,7 +147,7 @@ const initState = (key, c) => {
             currentRound: 0,
             players: {},
             participants: [],
-            difficulty: '',
+            difficulty: c.wzHero.defaultDifficulty,
             botAnswered: false,
             lastHint: '',
             currentHeroId: '',
@@ -301,27 +174,7 @@ const initState = (key, c) => {
             botTurn: true,
             autoPlayCount: 0,
             hasTriggeredAutoPlay: false,
-            lastActiveTime: Date.now(),
-            autoPlayTimer: undefined
-        },
-        dice: {
-            started: false,
-            totalRounds: c.dice.totalRounds,
-            currentRound: 0,
-            players: {},
-            participants: [],
-            playerDice: 0,
-            botDice: 0
-        },
-        rps: {
-            started: false,
-            totalRounds: c.rps.totalRounds,
-            currentRound: 0,
-            players: {},
-            participants: [],
-            playerChoice: '',
-            botChoice: '',
-            choices: ['石头', '剪刀', '布']
+            lastActiveTime: Date.now()
         },
         calc24: {
             started: false,
@@ -329,8 +182,11 @@ const initState = (key, c) => {
             currentRound: 0,
             players: {},
             participants: [],
+            difficulty: c.calc24.defaultDifficulty,
             numbers: [],
-            playerAnswer: ''
+            playerAnswer: '',
+            solved: false,
+            availableNumbers: []
         },
         passwordLock: {
             started: false,
@@ -342,7 +198,8 @@ const initState = (key, c) => {
             playerGuess: '',
             guessTimes: 0,
             maxGuessTimes: c.passwordLock.maxGuessTimes,
-            hints: []
+            hints: [],
+            solved: false
         }
     };
     gameStates.set(key, s);
@@ -378,9 +235,22 @@ const addScoreToOthers = (players, excludePlayerKey) => {
         }
     });
 };
-const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
+const setupAutoStop = (session, state, cfg, gameType, endMsg, showRank) => {
     clearGameTimer(state);
-    if (cfg.autoStopInactiveTime <= 0)
+    let inactiveTime = 30;
+    if (gameType === 'guessNumber')
+        inactiveTime = cfg.guessNumber.autoStopInactiveTime;
+    else if (gameType === 'wzHero')
+        inactiveTime = cfg.wzHero.autoStopInactiveTime;
+    else if (gameType === 'chengyuImage')
+        inactiveTime = cfg.chengyuImage.autoStopInactiveTime;
+    else if (gameType === 'chengyuJielong')
+        inactiveTime = cfg.chengyuJielong.autoStopInactiveTime;
+    else if (gameType === 'calc24')
+        inactiveTime = cfg.calc24.autoStopInactiveTime;
+    else if (gameType === 'passwordLock')
+        inactiveTime = cfg.passwordLock.autoStopInactiveTime;
+    if (inactiveTime <= 0)
         return;
     state.stopTimer = setTimeout(() => {
         clearGameData(state);
@@ -388,7 +258,7 @@ const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
         if (showRank && session.channelId) {
             session.send(generateRankText(state.players));
         }
-    }, cfg.autoStopInactiveTime * 1000);
+    }, inactiveTime * 1000);
 };
 const calculate24 = (numbers) => {
     if (numbers.length === 1)
@@ -420,6 +290,21 @@ const calculate24 = (numbers) => {
     }
     return false;
 };
+const generateSolvable24Numbers = (min, max) => {
+    const maxAttempts = 1000;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const numbers = [
+            koishi_1.Random.int(min, max + 1),
+            koishi_1.Random.int(min, max + 1),
+            koishi_1.Random.int(min, max + 1),
+            koishi_1.Random.int(min, max + 1)
+        ];
+        if (calculate24([...numbers])) {
+            return numbers;
+        }
+    }
+    return [6, 4, 3, 1];
+};
 const generatePasswordHint = (password, guess) => {
     let correctPos = 0;
     let correctNum = 0;
@@ -447,6 +332,21 @@ const generatePasswordHint = (password, guess) => {
     }
     return `提示：${correctPos}个数字位置正确，${correctNum}个数字正确但位置错误`;
 };
+const evaluateExpression = (expr) => {
+    try {
+        const cleanExpr = expr.replace(/[^\d\+\-\*\/\(\)\[\]\{\}\s]/g, '');
+        const normalizedExpr = cleanExpr.replace(/[\[\{]/g, '(').replace(/[\]\}]/g, ')');
+        const func = new Function('return ' + normalizedExpr);
+        const result = func();
+        if (typeof result === 'number' && isFinite(result)) {
+            return result;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
 function apply(ctx, cfg) {
     const d = {
         guessNumber: {
@@ -465,23 +365,23 @@ function apply(ctx, cfg) {
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         wzHero: {
-            start: "王者英雄猜谜开始！本次共 {0} 回合～",
-            startUsage: "用法错误！正确用法：王者英雄 开始 [难度] | 王者英雄 [答案] | 王者英雄 提示 | 王者英雄 结束",
-            stop: "王者英雄猜谜比赛已停止",
-            notStarted: "王者英雄猜谜比赛尚未开始，请输入 王者英雄 开始 [难度] 开始游戏",
+            start: "猜王者英雄开始！本次共 {0} 回合～当前难度：{1}",
+            startUsage: "用法错误！正确用法：猜王者英雄 开始 | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束",
+            stop: "猜王者英雄比赛已停止",
+            notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 开始游戏",
             hint: "提示",
             apiError: "API请求失败，请稍后再试",
             correct: "答对啦！你获得1分～",
             wrong: "答错啦～正确答案是：{0}，你不得分",
             roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 王者英雄猜谜比赛结束！🎉",
+            gameEnd: "🎉 猜王者英雄比赛结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
             rankEmpty: "暂无参与记录～",
-            disabled: "王者英雄猜谜功能已关闭，请联系管理员开启",
+            disabled: "猜王者英雄功能已关闭，请联系管理员开启",
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         chengyuImage: {
-            start: "看图猜成语比赛开始！本次共 {0} 回合～",
+            start: "看图猜成语比赛开始！本次共 {0} 回合～当前提示级别：{1}",
             stop: "看图猜成语比赛已停止",
             submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
             notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
@@ -518,45 +418,15 @@ function apply(ctx, cfg) {
             disabled: "成语接龙功能已关闭，请联系管理员开启",
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
-        dice: {
-            start: "掷骰子比大小游戏开始！本次共 {0} 回合～",
-            stop: "掷骰子比大小游戏已停止",
-            notStarted: "掷骰子比大小游戏尚未开始，请输入 掷骰子 开始 开始游戏",
-            roll: "🎲 你掷出了 {0} 点！机器人掷出了 {1} 点！",
-            win: "你赢了这一回合！获得1分～",
-            lose: "机器人赢了这一回合！",
-            draw: "平局！双方都不得分～",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 掷骰子比大小游戏结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "掷骰子比大小功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        rps: {
-            start: "石头剪刀布游戏开始！本次共 {0} 回合～",
-            stop: "石头剪刀布游戏已停止",
-            notStarted: "石头剪刀布游戏尚未开始，请输入 石头剪刀布 开始 开始游戏",
-            choice: "你选择了 {0}，机器人选择了 {1}！",
-            win: "你赢了这一回合！获得1分～",
-            lose: "机器人赢了这一回合！",
-            draw: "平局！双方都不得分～",
-            invalidChoice: "无效的选择！请输入 石头、剪刀 或 布",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 石头剪刀布游戏结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "石头剪刀布功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
         calc24: {
-            start: "算24点游戏开始！本次共 {0} 回合～",
+            start: "算24点游戏开始！本次共 {0} 回合～当前难度：{1}",
             stop: "算24点游戏已停止",
             notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
-            generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
+            generate: "📝 第 {0} 题（{1}）：用 {2} 通过加减乘除和括号算出24！",
             correct: "答对啦！你获得1分～",
-            wrong: "答错啦～这组数可以算出24哦！",
-            impossible: "这组数无法算出24！本轮作废～",
+            wrong: "答错啦～",
+            impossible: "这组数无法算出24！本题作废，换一组数字～",
+            solved: "这组数已经被答对啦，换一组数字～",
             roundEnd: "第 {0} 回合结束！剩余回合：{1}",
             gameEnd: "🎉 算24点游戏结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
@@ -565,18 +435,19 @@ function apply(ctx, cfg) {
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         passwordLock: {
-            start: "密码锁破解游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
-            stop: "密码锁破解游戏已停止",
-            notStarted: "密码锁破解游戏尚未开始，请输入 密码锁 开始 开始游戏",
+            start: "猜密码游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
+            stop: "猜密码游戏已停止",
+            notStarted: "猜密码游戏尚未开始，请输入 猜密码 开始 开始游戏",
             guess: "你猜测的密码是：{0}，这是第 {1} 次猜测",
             correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～",
             wrong: "密码错误！{0}",
+            solved: "密码已经被猜出来啦，游戏结束～",
             noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
             invalidPassword: "无效的密码！请输入4位数字",
-            gameEnd: "🎉 密码锁破解游戏结束！🎉",
+            gameEnd: "🎉 猜密码游戏结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
             rankEmpty: "暂无参与记录～",
-            disabled: "密码锁破解功能已关闭，请联系管理员开启",
+            disabled: "猜密码功能已关闭，请联系管理员开启",
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         common: {
@@ -609,7 +480,7 @@ function apply(ctx, cfg) {
             return;
         if (st.chengyuJielong.hasTriggeredAutoPlay)
             return;
-        const delay = cfg.autoPlayDelay * 1000;
+        const delay = cfg.chengyuJielong.autoPlayDelay * 1000;
         st.chengyuJielong.autoPlayTimer = setTimeout(() => {
             doAutoPlay(session, key, st);
         }, delay);
@@ -619,11 +490,11 @@ function apply(ctx, cfg) {
             return;
         if (st.chengyuJielong.hasTriggeredAutoPlay)
             return;
-        if (st.chengyuJielong.autoPlayCount >= cfg.autoPlayMaxCount) {
-            session.send(d.chengyuJielong.autoPlayTooMany.replace('{0}', String(cfg.autoPlayMaxCount)));
+        if (st.chengyuJielong.autoPlayCount >= cfg.chengyuJielong.autoPlayMaxCount) {
+            session.send(d.chengyuJielong.autoPlayTooMany.replace('{0}', String(cfg.chengyuJielong.autoPlayMaxCount)));
             st.chengyuJielong.hasTriggeredAutoPlay = true;
             gameStates.set(key, st);
-            setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+            setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
             return;
         }
         st.chengyuJielong.hasTriggeredAutoPlay = true;
@@ -674,7 +545,7 @@ function apply(ctx, cfg) {
             await session.send(d.chengyuJielong.apiError);
         }
         gameStates.set(key, st);
-        setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+        setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
     };
     ctx.middleware(async (session, next) => {
         if (!session.content)
@@ -693,7 +564,7 @@ function apply(ctx, cfg) {
                 st.chengyuJielong.participants.push(playerKey);
             }
             if (!isFourCharIdiom(content)) {
-                setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+                setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
                 scheduleAutoPlay(session, key, st);
                 return next();
             }
@@ -743,7 +614,7 @@ function apply(ctx, cfg) {
                         m += '\n' + d.chengyuJielong.roundEnd.replace('{0}', st.chengyuJielong.currentRound.toString()).replace('{1}', (st.chengyuJielong.totalRounds - st.chengyuJielong.currentRound).toString());
                         await session.send(m);
                         st.chengyuJielong.hasTriggeredAutoPlay = false;
-                        setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+                        setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
                         scheduleAutoPlay(session, key, st);
                     }
                 }
@@ -756,7 +627,7 @@ function apply(ctx, cfg) {
             }
             catch (error) {
                 await session.send(d.chengyuJielong.apiError);
-                setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+                setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
                 scheduleAutoPlay(session, key, st);
             }
             gameStates.set(key, st);
@@ -774,7 +645,7 @@ function apply(ctx, cfg) {
                         params: {
                             action: 'get_hint',
                             id: st.chengyuImage.currentId,
-                            level: 1
+                            level: cfg.chengyuImage.defaultHintLevel
                         },
                         timeout: cfg.apiConfig.timeout
                     });
@@ -789,11 +660,11 @@ function apply(ctx, cfg) {
                 catch (error) {
                     await session.send(d.chengyuImage.hintError);
                 }
-                setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
+                setupAutoStop(session, st.chengyuImage, cfg, 'chengyuImage', d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
                 return;
             }
             if (!isFourCharIdiom(content)) {
-                setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
+                setupAutoStop(session, st.chengyuImage, cfg, 'chengyuImage', d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
                 return next();
             }
             try {
@@ -869,7 +740,7 @@ function apply(ctx, cfg) {
             catch (error) {
                 await session.send(d.chengyuImage.apiError);
             }
-            setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
+            setupAutoStop(session, st.chengyuImage, cfg, 'chengyuImage', d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
             gameStates.set(key, st);
             return;
         }
@@ -879,6 +750,12 @@ function apply(ctx, cfg) {
                 st.wzHero.players[playerKey] = getPlayerData(session);
                 st.wzHero.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.wzHero);
+                await session.send(d.wzHero.stop);
+                gameStates.set(key, st);
+                return;
+            }
             try {
                 const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
                     params: { id: getIntUserId(session), msg: content }, timeout: cfg.apiConfig.timeout
@@ -931,7 +808,7 @@ function apply(ctx, cfg) {
             catch (error) {
                 await session.send(d.wzHero.apiError);
             }
-            setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
+            setupAutoStop(session, st.wzHero, cfg, 'wzHero', d.wzHero.autoStop, cfg.wzHero.showRank);
             gameStates.set(key, st);
             return;
         }
@@ -941,9 +818,15 @@ function apply(ctx, cfg) {
                 st.guessNumber.players[playerKey] = getPlayerData(session);
                 st.guessNumber.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.guessNumber);
+                await session.send(d.guessNumber.stop);
+                gameStates.set(key, st);
+                return;
+            }
             const num = parseInt(content);
             if (isNaN(num)) {
-                setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
+                setupAutoStop(session, st.guessNumber, cfg, 'guessNumber', d.guessNumber.autoStop, cfg.guessNumber.showRank);
                 return next();
             }
             if (num === st.guessNumber.target) {
@@ -974,108 +857,7 @@ function apply(ctx, cfg) {
                 st.guessNumber.currentMax = num - 1;
                 await session.send(d.guessNumber.tooBig.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
             }
-            setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
-            gameStates.set(key, st);
-            return;
-        }
-        if (cfg.enableDice && st.dice.started) {
-            clearGameTimer(st.dice);
-            if (!st.dice.players[playerKey]) {
-                st.dice.players[playerKey] = getPlayerData(session);
-                st.dice.participants.push(playerKey);
-            }
-            if (content !== '掷骰子') {
-                setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
-                return next();
-            }
-            st.dice.playerDice = koishi_1.Random.int(1, 6);
-            st.dice.botDice = cfg.dice.botParticipate ? koishi_1.Random.int(1, 6) : 0;
-            let resultMsg = d.dice.roll.replace('{0}', st.dice.playerDice.toString()).replace('{1}', st.dice.botDice.toString());
-            if (cfg.dice.botParticipate) {
-                if (st.dice.playerDice > st.dice.botDice) {
-                    resultMsg += '\n' + d.dice.win;
-                    st.dice.players[playerKey].score += 1;
-                    st.dice.players[playerKey].correctCount += 1;
-                }
-                else if (st.dice.playerDice < st.dice.botDice) {
-                    resultMsg += '\n' + d.dice.lose;
-                }
-                else {
-                    resultMsg += '\n' + d.dice.draw;
-                }
-            }
-            else {
-                resultMsg += '\n你掷出了 ' + st.dice.playerDice + ' 点！';
-                st.dice.players[playerKey].score += 1;
-            }
-            await session.send(resultMsg);
-            st.dice.currentRound += 1;
-            if (st.dice.currentRound > st.dice.totalRounds) {
-                st.dice.started = false;
-                clearGameTimer(st.dice);
-                await session.send(d.dice.gameEnd);
-                if (cfg.dice.showRank && !isPrivate(session)) {
-                    const rankText = generateRankText(st.dice.players);
-                    await session.send(rankText);
-                }
-                clearGameData(st.dice);
-            }
-            else {
-                await session.send(d.dice.roundEnd.replace('{0}', st.dice.currentRound.toString()).replace('{1}', (st.dice.totalRounds - st.dice.currentRound).toString()));
-            }
-            setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
-            gameStates.set(key, st);
-            return;
-        }
-        if (cfg.enableRps && st.rps.started) {
-            clearGameTimer(st.rps);
-            if (!st.rps.players[playerKey]) {
-                st.rps.players[playerKey] = getPlayerData(session);
-                st.rps.participants.push(playerKey);
-            }
-            if (!st.rps.choices.includes(content)) {
-                await session.send(d.rps.invalidChoice);
-                setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
-                return next();
-            }
-            st.rps.playerChoice = content;
-            st.rps.botChoice = cfg.rps.botParticipate ? st.rps.choices[koishi_1.Random.int(0, 2)] : '';
-            let resultMsg = d.rps.choice.replace('{0}', st.rps.playerChoice).replace('{1}', st.rps.botChoice);
-            if (cfg.rps.botParticipate) {
-                if ((st.rps.playerChoice === '石头' && st.rps.botChoice === '剪刀') ||
-                    (st.rps.playerChoice === '剪刀' && st.rps.botChoice === '布') ||
-                    (st.rps.playerChoice === '布' && st.rps.botChoice === '石头')) {
-                    resultMsg += '\n' + d.rps.win;
-                    st.rps.players[playerKey].score += 1;
-                    st.rps.players[playerKey].correctCount += 1;
-                }
-                else if (st.rps.playerChoice === st.rps.botChoice) {
-                    resultMsg += '\n' + d.rps.draw;
-                }
-                else {
-                    resultMsg += '\n' + d.rps.lose;
-                }
-            }
-            else {
-                resultMsg += '\n你选择了 ' + st.rps.playerChoice + '！';
-                st.rps.players[playerKey].score += 1;
-            }
-            await session.send(resultMsg);
-            st.rps.currentRound += 1;
-            if (st.rps.currentRound > st.rps.totalRounds) {
-                st.rps.started = false;
-                clearGameTimer(st.rps);
-                await session.send(d.rps.gameEnd);
-                if (cfg.rps.showRank && !isPrivate(session)) {
-                    const rankText = generateRankText(st.rps.players);
-                    await session.send(rankText);
-                }
-                clearGameData(st.rps);
-            }
-            else {
-                await session.send(d.rps.roundEnd.replace('{0}', st.rps.currentRound.toString()).replace('{1}', (st.rps.totalRounds - st.rps.currentRound).toString()));
-            }
-            setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
+            setupAutoStop(session, st.guessNumber, cfg, 'guessNumber', d.guessNumber.autoStop, cfg.guessNumber.showRank);
             gameStates.set(key, st);
             return;
         }
@@ -1085,56 +867,62 @@ function apply(ctx, cfg) {
                 st.calc24.players[playerKey] = getPlayerData(session);
                 st.calc24.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.calc24);
+                await session.send(d.calc24.stop);
+                gameStates.set(key, st);
+                return;
+            }
             if (content === '换题') {
-                st.calc24.numbers = [];
-                for (let i = 0; i < 4; i++) {
-                    st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
+                if (!st.calc24.solved) {
+                    const range = cfg.calc24.difficultyLevels[st.calc24.difficulty === '简单' ? 'easy' :
+                        st.calc24.difficulty === '中等' ? 'medium' : 'hard'];
+                    st.calc24.numbers = generateSolvable24Numbers(range.min, range.max);
+                    st.calc24.solved = false;
+                    await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString())
+                        .replace('{1}', st.calc24.difficulty)
+                        .replace('{2}', st.calc24.numbers.join('、')));
                 }
-                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-                setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
-                return next();
+                setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank);
+                return;
             }
-            st.calc24.playerAnswer = content;
-            const canCalculate = calculate24([...st.calc24.numbers]);
-            if (!canCalculate) {
-                await session.send(d.calc24.impossible);
+            if (st.calc24.solved) {
+                await session.send(d.calc24.solved);
+                setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank);
+                return;
             }
-            else {
-                try {
-                    const result = eval(content.replace(/[^\d\+\-\*\/\(\)\.]/g, ''));
-                    if (Math.abs(result - 24) < 0.001) {
-                        await session.send(d.calc24.correct);
-                        st.calc24.players[playerKey].score += 1;
-                        st.calc24.players[playerKey].correctCount += 1;
-                    }
-                    else {
-                        await session.send(d.calc24.wrong);
+            const result = evaluateExpression(content);
+            if (result !== null && Math.abs(result - 24) < 0.001) {
+                await session.send(d.calc24.correct);
+                st.calc24.players[playerKey].score += 1;
+                st.calc24.players[playerKey].correctCount += 1;
+                st.calc24.solved = true;
+                st.calc24.currentRound += 1;
+                if (st.calc24.currentRound > st.calc24.totalRounds) {
+                    st.calc24.started = false;
+                    clearGameTimer(st.calc24);
+                    await session.send(d.calc24.gameEnd);
+                    if (cfg.calc24.showRank && !isPrivate(session)) {
+                        const rankText = generateRankText(st.calc24.players);
+                        await session.send(rankText);
                     }
+                    clearGameData(st.calc24);
                 }
-                catch {
-                    await session.send(d.calc24.wrong);
-                }
-            }
-            st.calc24.currentRound += 1;
-            if (st.calc24.currentRound > st.calc24.totalRounds) {
-                st.calc24.started = false;
-                clearGameTimer(st.calc24);
-                await session.send(d.calc24.gameEnd);
-                if (cfg.calc24.showRank && !isPrivate(session)) {
-                    const rankText = generateRankText(st.calc24.players);
-                    await session.send(rankText);
+                else {
+                    await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
+                    const range = cfg.calc24.difficultyLevels[st.calc24.difficulty === '简单' ? 'easy' :
+                        st.calc24.difficulty === '中等' ? 'medium' : 'hard'];
+                    st.calc24.numbers = generateSolvable24Numbers(range.min, range.max);
+                    st.calc24.solved = false;
+                    await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString())
+                        .replace('{1}', st.calc24.difficulty)
+                        .replace('{2}', st.calc24.numbers.join('、')));
                 }
-                clearGameData(st.calc24);
             }
             else {
-                st.calc24.numbers = [];
-                for (let i = 0; i < 4; i++) {
-                    st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
-                }
-                await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
-                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+                await session.send(d.calc24.wrong);
             }
-            setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+            setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank);
             gameStates.set(key, st);
             return;
         }
@@ -1144,18 +932,31 @@ function apply(ctx, cfg) {
                 st.passwordLock.players[playerKey] = getPlayerData(session);
                 st.passwordLock.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.passwordLock);
+                await session.send(d.passwordLock.stop);
+                gameStates.set(key, st);
+                return;
+            }
+            if (st.passwordLock.solved) {
+                await session.send(d.passwordLock.solved);
+                setupAutoStop(session, st.passwordLock, cfg, 'passwordLock', d.passwordLock.autoStop, cfg.passwordLock.showRank);
+                return;
+            }
             if (!/^\d{4}$/.test(content)) {
                 await session.send(d.passwordLock.invalidPassword);
-                setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
-                return next();
+                setupAutoStop(session, st.passwordLock, cfg, 'passwordLock', d.passwordLock.autoStop, cfg.passwordLock.showRank);
+                return;
             }
             st.passwordLock.playerGuess = content;
             st.passwordLock.guessTimes += 1;
             await session.send(d.passwordLock.guess.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
             if (content === st.passwordLock.password) {
+                const score = 10 - (st.passwordLock.guessTimes - 1);
                 await session.send(d.passwordLock.correct.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
-                st.passwordLock.players[playerKey].score += 10 - (st.passwordLock.guessTimes - 1);
+                st.passwordLock.players[playerKey].score += score > 0 ? score : 1;
                 st.passwordLock.players[playerKey].correctCount += 1;
+                st.passwordLock.solved = true;
                 st.passwordLock.started = false;
                 clearGameTimer(st.passwordLock);
                 await session.send(d.passwordLock.gameEnd);
@@ -1169,6 +970,10 @@ function apply(ctx, cfg) {
                 let hint = '';
                 if (cfg.passwordLock.showHint) {
                     hint = generatePasswordHint(st.passwordLock.password, content);
+                    await session.send(d.passwordLock.wrong.replace('{0}', hint));
+                }
+                else {
+                    await session.send(d.passwordLock.wrong.replace('{0}', ''));
                 }
                 if (st.passwordLock.guessTimes >= st.passwordLock.maxGuessTimes) {
                     await session.send(d.passwordLock.noChance.replace('{0}', st.passwordLock.password));
@@ -1182,11 +987,10 @@ function apply(ctx, cfg) {
                     clearGameData(st.passwordLock);
                 }
                 else {
-                    await session.send(d.passwordLock.wrong.replace('{0}', hint));
                     await session.send(`剩余猜测次数：${st.passwordLock.maxGuessTimes - st.passwordLock.guessTimes}`);
                 }
             }
-            setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+            setupAutoStop(session, st.passwordLock, cfg, 'passwordLock', d.passwordLock.autoStop, cfg.passwordLock.showRank);
             gameStates.set(key, st);
             return;
         }
@@ -1199,7 +1003,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'guessNumber')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1212,7 +1016,7 @@ function apply(ctx, cfg) {
             await session.send(d.guessNumber.start.replace('{0}', st.guessNumber.totalRounds.toString()));
             await session.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}`);
             gameStates.set(key, st);
-            setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
+            setupAutoStop(session, st.guessNumber, cfg, 'guessNumber', d.guessNumber.autoStop, cfg.guessNumber.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.guessNumber);
@@ -1223,20 +1027,20 @@ function apply(ctx, cfg) {
             await session.send(d.guessNumber.usage);
         }
     });
-    ctx.command('王者英雄 <action> [param]', '王者英雄猜谜')
+    ctx.command('猜王者英雄 <action> [param]', '猜王者英雄猜谜')
         .action(async (argv, action, param) => {
         const session = argv.session;
         if (!session)
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'wzHero')) {
             await session.send(d.common.gameRunning);
             return;
         }
         if (action === '开始') {
             st.wzHero.started = true;
-            st.wzHero.difficulty = param || '简单';
+            st.wzHero.difficulty = cfg.wzHero.defaultDifficulty;
             st.wzHero.currentRound = 1;
             try {
                 const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
@@ -1246,7 +1050,7 @@ function apply(ctx, cfg) {
                 const dt = r.data;
                 let text = `${dt.message || ''}\n${dt.hint || ''}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide || ''}`;
                 text = text.replace(/\\n/g, '\n');
-                await session.send(d.wzHero.start.replace('{0}', st.wzHero.totalRounds.toString()));
+                await session.send(d.wzHero.start.replace('{0}', st.wzHero.totalRounds.toString()).replace('{1}', st.wzHero.difficulty));
                 await session.send(text);
                 st.wzHero.currentAnswer = dt.hint || '';
             }
@@ -1254,7 +1058,7 @@ function apply(ctx, cfg) {
                 await session.send(d.wzHero.apiError);
             }
             gameStates.set(key, st);
-            setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
+            setupAutoStop(session, st.wzHero, cfg, 'wzHero', d.wzHero.autoStop, cfg.wzHero.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.wzHero);
@@ -1272,7 +1076,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'chengyuImage')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1290,7 +1094,7 @@ function apply(ctx, cfg) {
                     st.chengyuImage.currentPage = dt.data.question.page;
                     st.chengyuImage.options = dt.data.question.options;
                     st.chengyuImage.answer = dt.data.question.answer || '';
-                    await session.send(d.chengyuImage.start.replace('{0}', st.chengyuImage.totalRounds.toString()));
+                    await session.send(d.chengyuImage.start.replace('{0}', st.chengyuImage.totalRounds.toString()).replace('{1}', cfg.chengyuImage.defaultHintLevel.toString()));
                     await session.send(`请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
                     await session.send(koishi_1.segment.image(dt.data.question.image_url));
                 }
@@ -1302,7 +1106,7 @@ function apply(ctx, cfg) {
                 await session.send(d.chengyuImage.apiError);
             }
             gameStates.set(key, st);
-            setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
+            setupAutoStop(session, st.chengyuImage, cfg, 'chengyuImage', d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.chengyuImage);
@@ -1320,7 +1124,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'chengyuJielong')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1332,7 +1136,7 @@ function apply(ctx, cfg) {
             await session.send(d.chengyuJielong.start.replace('{0}', st.chengyuJielong.totalRounds.toString()));
             gameStates.set(key, st);
             scheduleAutoPlay(session, key, st);
-            setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
+            setupAutoStop(session, st.chengyuJielong, cfg, 'chengyuJielong', d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.chengyuJielong);
@@ -1343,54 +1147,6 @@ function apply(ctx, cfg) {
             await session.send(d.chengyuJielong.joinUsage);
         }
     });
-    ctx.command('掷骰子 <action>', '掷骰子比大小')
-        .action(async (argv, action) => {
-        const session = argv.session;
-        if (!session)
-            return;
-        const key = getSessionKey(session);
-        const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
-            await session.send(d.common.gameRunning);
-            return;
-        }
-        if (action === '开始') {
-            st.dice.started = true;
-            st.dice.currentRound = 1;
-            await session.send(d.dice.start.replace('{0}', st.dice.totalRounds.toString()));
-            gameStates.set(key, st);
-            setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
-        }
-        else if (action === '结束') {
-            clearGameData(st.dice);
-            await session.send(d.dice.stop);
-            gameStates.set(key, st);
-        }
-    });
-    ctx.command('石头剪刀布 <action>', '石头剪刀布')
-        .action(async (argv, action) => {
-        const session = argv.session;
-        if (!session)
-            return;
-        const key = getSessionKey(session);
-        const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
-            await session.send(d.common.gameRunning);
-            return;
-        }
-        if (action === '开始') {
-            st.rps.started = true;
-            st.rps.currentRound = 1;
-            await session.send(d.rps.start.replace('{0}', st.rps.totalRounds.toString()));
-            gameStates.set(key, st);
-            setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
-        }
-        else if (action === '结束') {
-            clearGameData(st.rps);
-            await session.send(d.rps.stop);
-            gameStates.set(key, st);
-        }
-    });
     ctx.command('算24点 <action>', '算24点游戏')
         .action(async (argv, action) => {
         const session = argv.session;
@@ -1398,36 +1154,42 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'calc24')) {
             await session.send(d.common.gameRunning);
             return;
         }
         if (action === '开始') {
+            st.calc24.difficulty = cfg.calc24.defaultDifficulty;
             st.calc24.started = true;
             st.calc24.currentRound = 1;
-            st.calc24.numbers = [];
-            for (let i = 0; i < 4; i++) {
-                st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
-            }
-            await session.send(d.calc24.start.replace('{0}', st.calc24.totalRounds.toString()));
-            await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+            st.calc24.solved = false;
+            const range = cfg.calc24.difficultyLevels[st.calc24.difficulty === '简单' ? 'easy' :
+                st.calc24.difficulty === '中等' ? 'medium' : 'hard'];
+            st.calc24.numbers = generateSolvable24Numbers(range.min, range.max);
+            await session.send(d.calc24.start.replace('{0}', st.calc24.totalRounds.toString()).replace('{1}', st.calc24.difficulty));
+            await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString())
+                .replace('{1}', st.calc24.difficulty)
+                .replace('{2}', st.calc24.numbers.join('、')));
             gameStates.set(key, st);
-            setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+            setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.calc24);
             await session.send(d.calc24.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：算24点 开始 或 算24点 结束');
+        }
     });
-    ctx.command('密码锁 <action>', '密码锁破解')
+    ctx.command('猜密码 <action>', '猜密码游戏')
         .action(async (argv, action) => {
         const session = argv.session;
         if (!session)
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'passwordLock')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1435,15 +1197,19 @@ function apply(ctx, cfg) {
             st.passwordLock.started = true;
             st.passwordLock.currentRound = 1;
             st.passwordLock.guessTimes = 0;
+            st.passwordLock.solved = false;
             st.passwordLock.password = koishi_1.Random.int(1000, 9999).toString();
             await session.send(d.passwordLock.start.replace('{0}', st.passwordLock.maxGuessTimes.toString()));
             gameStates.set(key, st);
-            setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+            setupAutoStop(session, st.passwordLock, cfg, 'passwordLock', d.passwordLock.autoStop, cfg.passwordLock.showRank);
         }
         else if (action === '结束') {
             clearGameData(st.passwordLock);
             await session.send(d.passwordLock.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：猜密码 开始 或 猜密码 结束');
+        }
     });
 }