koishi-plugin-game-mini 0.2.4 → 0.2.6

package/lib/index.js

@@ -13,195 +13,263 @@ const axios_1 = __importDefault(require("axios"));
 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': '游戏无操作自动停止时间（秒）' }),
-    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': '猜数字游戏配置' }),
-    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': '王者英雄猜谜游戏配置' }),
-    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': '看图猜成语游戏配置' }),
-    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': '石头剪刀布游戏配置' }),
-    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点游戏配置' }),
-    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': '密码锁破解游戏配置' }),
-    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': '请求超时时间(毫秒)'
+const defaultMessages = {
+    guessNumber: {
+        usage: "用法错误！正确用法：猜数字 开始 | 猜数字 [数字] | 猜数字 结束",
+        start: "猜数字比赛开始！本次共 {0} 回合～",
+        stop: "猜数字比赛已停止",
+        outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！",
+        tooSmall: "猜小啦！当前范围更新为 [{0}-{1}]",
+        tooBig: "猜大啦！当前范围更新为 [{0}-{1}]",
+        correct: "恭喜你猜中数字！本轮你不得分，其他参与者各得1分～",
+        roundEnd: "第 {0} 回合结束！剩余回合：{1}",
+        gameEnd: "🎉 猜数字比赛结束！🎉",
+        rankTitle: "🏆 排行榜 🏆",
+        rankEmpty: "暂无参与记录～",
+        disabled: "猜数字功能已关闭，请联系管理员开启",
+        autoStop: "游戏因长时间无人操作，已自动结束"
+    },
+    wzHero: {
+        start: "猜王者英雄开始！本次共 {0} 回合～当前难度：{1}",
+        startUsage: "用法错误！正确用法：猜王者英雄 开始 | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束",
+        stop: "猜王者英雄比赛已停止",
+        notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 开始游戏",
+        hint: "提示",
+        apiError: "API请求失败，请稍后再试",
+        correct: "答对啦！你获得1分～",
+        wrong: "答错啦～正确答案是：{0}，你不得分",
+        roundEnd: "第 {0} 回合结束！剩余回合：{1}",
+        gameEnd: "🎉 猜王者英雄比赛结束！🎉",
+        rankTitle: "🏆 排行榜 🏆",
+        rankEmpty: "暂无参与记录～",
+        disabled: "猜王者英雄功能已关闭，请联系管理员开启",
+        autoStop: "游戏因长时间无人操作，已自动结束"
+    },
+    chengyuImage: {
+        start: "看图猜成语比赛开始！本次共 {0} 回合～当前提示级别：{1}",
+        stop: "看图猜成语比赛已停止",
+        submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
+        notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
+        next: "第 {0} 题来啦！",
+        hintGet: "【提示】{0}",
+        hintError: "获取提示失败，请稍后再试",
+        apiError: "API请求失败，请稍后再试",
+        correct: "答对啦！你获得1分～",
+        wrong: "答错啦～正确答案是：{0}，你不得分",
+        roundEnd: "第 {0} 回合结束！剩余回合：{1}",
+        gameEnd: "🎉 看图猜成语比赛结束！🎉",
+        rankTitle: "🏆 排行榜 🏆",
+        rankEmpty: "暂无参与记录～",
+        disabled: "看图猜成语功能已关闭，请联系管理员开启",
+        autoStop: "游戏因长时间无人操作，已自动结束"
+    },
+    chengyuJielong: {
+        start: "成语接龙比赛开始！本次共 {0} 回合～我先来～",
+        stop: "成语接龙比赛已停止",
+        notStarted: "成语接龙比赛尚未开始，请输入 成语接龙 开始 开始游戏",
+        joinUsage: "请直接发送 成语接龙 [成语] 参与接龙",
+        apiError: "API请求失败，请稍后再试",
+        botTurn: "该我了！我接：{0}（{1}）\n释义：{2}",
+        botWin: "哈哈我接不上了！本轮结束～",
+        autoPlayTooMany: "我已经主动参与 {0} 次啦，不再主动接啦～",
+        gameInactiveStop: "太久没人玩啦，比赛自动结束～",
+        notIdiom: "请发送四字成语参与游戏～",
+        correct: "接龙成功！你获得1分～",
+        wrong: "接龙失败！你不得分，其他参与者各得1分～",
+        roundEnd: "第 {0} 回合结束！剩余回合：{1}",
+        gameEnd: "🎉 成语接龙比赛结束！🎉",
+        rankTitle: "🏆 排行榜 🏆",
+        rankEmpty: "暂无参与记录～",
+        disabled: "成语接龙功能已关闭，请联系管理员开启",
+        autoStop: "游戏因长时间无人操作，已自动结束"
+    },
+    calc24: {
+        start: "算24点游戏开始！本次共 {0} 回合～当前难度：{1}",
+        stop: "算24点游戏已停止",
+        notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
+        generate: "📝 第 {0} 题（{1}）：用 {2} 通过加减乘除和括号算出24！",
+        correct: "答对啦！你获得1分～",
+        wrong: "答错啦～",
+        impossible: "这组数无法算出24！本题作废，换一组数字～",
+        solved: "这组数已经被答对啦，换一组数字～",
+        roundEnd: "第 {0} 回合结束！剩余回合：{1}",
+        gameEnd: "🎉 算24点游戏结束！🎉",
+        rankTitle: "🏆 排行榜 🏆",
+        rankEmpty: "暂无参与记录～",
+        disabled: "算24点功能已关闭，请联系管理员开启",
+        autoStop: "游戏因长时间无人操作，已自动结束"
+    },
+    common: {
+        gameRunning: "当前已有游戏在运行中，请先结束当前游戏后再开始新游戏！",
+        gameStoppedByInactive: "游戏因长时间无人操作，已自动结束",
+        paramError: "参数错误！请检查输入格式"
     }
-});
+};
+exports.Config = koishi_1.Schema.intersect([
+    koishi_1.Schema.object({
+        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点游戏'),
+        enablePrivateGame: koishi_1.Schema.boolean().default(true).description('允许私聊玩游戏'),
+    }).description('基础功能开关'),
+    koishi_1.Schema.object({
+        guessNumber: koishi_1.Schema.object({
+            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(60).description('游戏无操作自动停止时间（秒）'),
+            messages: koishi_1.Schema.object({
+                usage: koishi_1.Schema.string().default(defaultMessages.guessNumber.usage).description('用法错误提示'),
+                start: koishi_1.Schema.string().default(defaultMessages.guessNumber.start).description('游戏开始提示'),
+                stop: koishi_1.Schema.string().default(defaultMessages.guessNumber.stop).description('游戏停止提示'),
+                outOfRange: koishi_1.Schema.string().default(defaultMessages.guessNumber.outOfRange).description('数字超出范围提示'),
+                tooSmall: koishi_1.Schema.string().default(defaultMessages.guessNumber.tooSmall).description('猜小了提示'),
+                tooBig: koishi_1.Schema.string().default(defaultMessages.guessNumber.tooBig).description('猜大了提示'),
+                correct: koishi_1.Schema.string().default(defaultMessages.guessNumber.correct).description('猜中提示'),
+                roundEnd: koishi_1.Schema.string().default(defaultMessages.guessNumber.roundEnd).description('回合结束提示'),
+                gameEnd: koishi_1.Schema.string().default(defaultMessages.guessNumber.gameEnd).description('游戏结束提示'),
+                rankTitle: koishi_1.Schema.string().default(defaultMessages.guessNumber.rankTitle).description('排行榜标题'),
+                rankEmpty: koishi_1.Schema.string().default(defaultMessages.guessNumber.rankEmpty).description('排行榜为空提示'),
+                disabled: koishi_1.Schema.string().default(defaultMessages.guessNumber.disabled).description('功能禁用提示'),
+                autoStop: koishi_1.Schema.string().default(defaultMessages.guessNumber.autoStop).description('自动停止提示'),
+            }).description('猜数字消息配置'),
+        }).description('猜数字游戏配置'),
+    }),
+    koishi_1.Schema.object({
+        wzHero: koishi_1.Schema.object({
+            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(60).description('游戏无操作自动停止时间（秒）'),
+            messages: koishi_1.Schema.object({
+                start: koishi_1.Schema.string().default(defaultMessages.wzHero.start).description('游戏开始提示'),
+                startUsage: koishi_1.Schema.string().default(defaultMessages.wzHero.startUsage).description('开始用法提示'),
+                stop: koishi_1.Schema.string().default(defaultMessages.wzHero.stop).description('游戏停止提示'),
+                notStarted: koishi_1.Schema.string().default(defaultMessages.wzHero.notStarted).description('游戏未开始提示'),
+                hint: koishi_1.Schema.string().default(defaultMessages.wzHero.hint).description('提示命令'),
+                apiError: koishi_1.Schema.string().default(defaultMessages.wzHero.apiError).description('API错误提示'),
+                correct: koishi_1.Schema.string().default(defaultMessages.wzHero.correct).description('答对提示'),
+                wrong: koishi_1.Schema.string().default(defaultMessages.wzHero.wrong).description('答错提示'),
+                roundEnd: koishi_1.Schema.string().default(defaultMessages.wzHero.roundEnd).description('回合结束提示'),
+                gameEnd: koishi_1.Schema.string().default(defaultMessages.wzHero.gameEnd).description('游戏结束提示'),
+                rankTitle: koishi_1.Schema.string().default(defaultMessages.wzHero.rankTitle).description('排行榜标题'),
+                rankEmpty: koishi_1.Schema.string().default(defaultMessages.wzHero.rankEmpty).description('排行榜为空提示'),
+                disabled: koishi_1.Schema.string().default(defaultMessages.wzHero.disabled).description('功能禁用提示'),
+                autoStop: koishi_1.Schema.string().default(defaultMessages.wzHero.autoStop).description('自动停止提示'),
+            }).description('王者英雄猜谜消息配置'),
+        }).description('王者英雄猜谜游戏配置'),
+    }),
+    koishi_1.Schema.object({
+        chengyuImage: koishi_1.Schema.object({
+            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(60).description('游戏无操作自动停止时间（秒）'),
+            messages: koishi_1.Schema.object({
+                start: koishi_1.Schema.string().default(defaultMessages.chengyuImage.start).description('游戏开始提示'),
+                stop: koishi_1.Schema.string().default(defaultMessages.chengyuImage.stop).description('游戏停止提示'),
+                submitUsage: koishi_1.Schema.string().default(defaultMessages.chengyuImage.submitUsage).description('提交答案用法提示'),
+                notStarted: koishi_1.Schema.string().default(defaultMessages.chengyuImage.notStarted).description('游戏未开始提示'),
+                next: koishi_1.Schema.string().default(defaultMessages.chengyuImage.next).description('下一题提示'),
+                hintGet: koishi_1.Schema.string().default(defaultMessages.chengyuImage.hintGet).description('获取提示成功'),
+                hintError: koishi_1.Schema.string().default(defaultMessages.chengyuImage.hintError).description('获取提示失败'),
+                apiError: koishi_1.Schema.string().default(defaultMessages.chengyuImage.apiError).description('API错误提示'),
+                correct: koishi_1.Schema.string().default(defaultMessages.chengyuImage.correct).description('答对提示'),
+                wrong: koishi_1.Schema.string().default(defaultMessages.chengyuImage.wrong).description('答错提示'),
+                roundEnd: koishi_1.Schema.string().default(defaultMessages.chengyuImage.roundEnd).description('回合结束提示'),
+                gameEnd: koishi_1.Schema.string().default(defaultMessages.chengyuImage.gameEnd).description('游戏结束提示'),
+                rankTitle: koishi_1.Schema.string().default(defaultMessages.chengyuImage.rankTitle).description('排行榜标题'),
+                rankEmpty: koishi_1.Schema.string().default(defaultMessages.chengyuImage.rankEmpty).description('排行榜为空提示'),
+                disabled: koishi_1.Schema.string().default(defaultMessages.chengyuImage.disabled).description('功能禁用提示'),
+                autoStop: koishi_1.Schema.string().default(defaultMessages.chengyuImage.autoStop).description('自动停止提示'),
+            }).description('看图猜成语消息配置'),
+        }).description('看图猜成语游戏配置'),
+    }),
+    koishi_1.Schema.object({
+        chengyuJielong: koishi_1.Schema.object({
+            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(60).description('游戏无操作自动停止时间（秒）'),
+            messages: koishi_1.Schema.object({
+                start: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.start).description('游戏开始提示'),
+                stop: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.stop).description('游戏停止提示'),
+                notStarted: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.notStarted).description('游戏未开始提示'),
+                joinUsage: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.joinUsage).description('参与用法提示'),
+                apiError: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.apiError).description('API错误提示'),
+                botTurn: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.botTurn).description('机器人回合提示'),
+                botWin: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.botWin).description('机器人赢提示'),
+                autoPlayTooMany: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.autoPlayTooMany).description('自动参与次数过多提示'),
+                gameInactiveStop: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.gameInactiveStop).description('游戏无操作停止提示'),
+                notIdiom: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.notIdiom).description('非成语提示'),
+                correct: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.correct).description('接龙成功提示'),
+                wrong: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.wrong).description('接龙失败提示'),
+                roundEnd: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.roundEnd).description('回合结束提示'),
+                gameEnd: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.gameEnd).description('游戏结束提示'),
+                rankTitle: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.rankTitle).description('排行榜标题'),
+                rankEmpty: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.rankEmpty).description('排行榜为空提示'),
+                disabled: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.disabled).description('功能禁用提示'),
+                autoStop: koishi_1.Schema.string().default(defaultMessages.chengyuJielong.autoStop).description('自动停止提示'),
+            }).description('成语接龙消息配置'),
+        }).description('成语接龙游戏配置'),
+    }),
+    koishi_1.Schema.object({
+        calc24: koishi_1.Schema.object({
+            totalRounds: koishi_1.Schema.number().min(1).default(5).description('算24点总回合数'),
+            showRank: koishi_1.Schema.boolean().default(true).description('显示排行榜'),
+            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(60).description('游戏无操作自动停止时间（秒）'),
+            messages: koishi_1.Schema.object({
+                start: koishi_1.Schema.string().default(defaultMessages.calc24.start).description('游戏开始提示'),
+                stop: koishi_1.Schema.string().default(defaultMessages.calc24.stop).description('游戏停止提示'),
+                notStarted: koishi_1.Schema.string().default(defaultMessages.calc24.notStarted).description('游戏未开始提示'),
+                generate: koishi_1.Schema.string().default(defaultMessages.calc24.generate).description('生成题目提示'),
+                correct: koishi_1.Schema.string().default(defaultMessages.calc24.correct).description('答对提示'),
+                wrong: koishi_1.Schema.string().default(defaultMessages.calc24.wrong).description('答错提示'),
+                impossible: koishi_1.Schema.string().default(defaultMessages.calc24.impossible).description('无解提示'),
+                solved: koishi_1.Schema.string().default(defaultMessages.calc24.solved).description('已解决提示'),
+                roundEnd: koishi_1.Schema.string().default(defaultMessages.calc24.roundEnd).description('回合结束提示'),
+                gameEnd: koishi_1.Schema.string().default(defaultMessages.calc24.gameEnd).description('游戏结束提示'),
+                rankTitle: koishi_1.Schema.string().default(defaultMessages.calc24.rankTitle).description('排行榜标题'),
+                rankEmpty: koishi_1.Schema.string().default(defaultMessages.calc24.rankEmpty).description('排行榜为空提示'),
+                disabled: koishi_1.Schema.string().default(defaultMessages.calc24.disabled).description('功能禁用提示'),
+                autoStop: koishi_1.Schema.string().default(defaultMessages.calc24.autoStop).description('自动停止提示'),
+            }).description('算24点消息配置'),
+        }).description('算24点游戏配置'),
+    }),
+    koishi_1.Schema.object({
+        apiConfig: koishi_1.Schema.object({
+            timeout: koishi_1.Schema.number().default(5000).description('API请求超时时间（毫秒）'),
+        }).description('API接口配置'),
+        commonMessages: koishi_1.Schema.object({
+            gameRunning: koishi_1.Schema.string().default(defaultMessages.common.gameRunning).description('游戏运行中提示'),
+            gameStoppedByInactive: koishi_1.Schema.string().default(defaultMessages.common.gameStoppedByInactive).description('无操作停止提示'),
+            paramError: koishi_1.Schema.string().default(defaultMessages.common.paramError).description('参数错误提示'),
+        }).description('通用消息配置'),
+    }),
+]);
 const logger = new koishi_1.Logger('game-mini');
 const gameStates = new Map();
 const getSessionKey = (s) => s.channelId ? `g:${s.channelId}` : `p:${s.userId}`;
@@ -229,31 +297,22 @@ 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)
-        return true;
     return false;
 };
 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 +333,7 @@ const initState = (key, c) => {
             currentRound: 0,
             players: {},
             participants: [],
-            difficulty: '',
+            difficulty: c.wzHero.defaultDifficulty,
             botAnswered: false,
             lastHint: '',
             currentHeroId: '',
@@ -301,27 +360,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,22 +368,11 @@ const initState = (key, c) => {
             currentRound: 0,
             players: {},
             participants: [],
+            difficulty: c.calc24.defaultDifficulty,
             numbers: [],
             playerAnswer: '',
-            solved: false
-        },
-        passwordLock: {
-            started: false,
-            totalRounds: 1,
-            currentRound: 0,
-            players: {},
-            participants: [],
-            password: '',
-            playerGuess: '',
-            guessTimes: 0,
-            maxGuessTimes: c.passwordLock.maxGuessTimes,
-            hints: [],
-            solved: false
+            solved: false,
+            availableNumbers: []
         }
     };
     gameStates.set(key, s);
@@ -354,19 +382,22 @@ const isFourCharIdiom = (text) => {
     const t = text.trim();
     return /^[\u4e00-\u9fa5]{4}$/.test(t);
 };
-const generateRankText = (players) => {
+const generateRankText = (players, rankTitle, rankEmpty) => {
     const playerList = Object.values(players);
     if (playerList.length === 0) {
-        return '🏆 排行榜 🏆\n暂无参与记录～';
+        return `${rankTitle}\n${rankEmpty}`;
     }
     const sortedPlayers = playerList.sort((a, b) => b.score - a.score);
-    let rankText = '🏆 排行榜 🏆\n';
+    let rankText = `${rankTitle}\n`;
     sortedPlayers.forEach((player, index) => {
         rankText += `${index + 1}. ${player.name} - 得分：${player.score}分（答对${player.correctCount}题）\n`;
     });
     return rankText.trim();
 };
-const clearGameData = (gameState) => {
+const clearGameData = (gameState, showRank = false, session, rankTitle, rankEmpty) => {
+    if (showRank && session && session.channelId && rankTitle && rankEmpty) {
+        session.send(generateRankText(gameState.players, rankTitle, rankEmpty));
+    }
     gameState.players = {};
     gameState.participants = [];
     gameState.currentRound = 0;
@@ -380,17 +411,25 @@ const addScoreToOthers = (players, excludePlayerKey) => {
         }
     });
 };
-const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
+const setupAutoStop = (session, state, cfg, gameType, endMsg, showRank, rankTitle, rankEmpty) => {
     clearGameTimer(state);
-    if (cfg.autoStopInactiveTime <= 0)
+    let inactiveTime = 60;
+    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;
+    if (inactiveTime <= 0)
         return;
     state.stopTimer = setTimeout(() => {
-        clearGameData(state);
+        clearGameData(state, showRank, session, rankTitle, rankEmpty);
         session.send(endMsg);
-        if (showRank && session.channelId) {
-            session.send(generateRankText(state.players));
-        }
-    }, cfg.autoStopInactiveTime * 1000);
+    }, inactiveTime * 1000);
 };
 const calculate24 = (numbers) => {
     if (numbers.length === 1)
@@ -422,172 +461,50 @@ const calculate24 = (numbers) => {
     }
     return false;
 };
-const generatePasswordHint = (password, guess) => {
-    let correctPos = 0;
-    let correctNum = 0;
-    const passwordArr = password.split('');
-    const guessArr = guess.split('');
-    const passwordUsed = [false, false, false, false];
-    const guessUsed = [false, false, false, false];
-    for (let i = 0; i < 4; i++) {
-        if (passwordArr[i] === guessArr[i]) {
-            correctPos++;
-            passwordUsed[i] = true;
-            guessUsed[i] = true;
+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;
         }
     }
-    for (let i = 0; i < 4; i++) {
-        if (guessUsed[i])
-            continue;
-        for (let j = 0; j < 4; j++) {
-            if (!passwordUsed[j] && passwordArr[j] === guessArr[i]) {
-                correctNum++;
-                passwordUsed[j] = true;
-                break;
-            }
+    return [6, 4, 3, 1];
+};
+const evaluateExpression = (expr) => {
+    try {
+        let cleanExpr = expr.replace(/\s+/g, '');
+        cleanExpr = cleanExpr.replace(/[×xX]/g, '*');
+        cleanExpr = cleanExpr.replace(/[÷/]/g, '/');
+        cleanExpr = cleanExpr.replace(/\/\//g, '/');
+        if (!/^[\d\+\-\*\/\(\)\[\]\{\}]+$/.test(cleanExpr)) {
+            return null;
+        }
+        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;
     }
-    return `提示：${correctPos}个数字位置正确，${correctNum}个数字正确但位置错误`;
 };
 function apply(ctx, cfg) {
     const d = {
-        guessNumber: {
-            usage: "用法错误！正确用法：猜数字 开始 | 猜数字 [数字] | 猜数字 结束",
-            start: "猜数字比赛开始！本次共 {0} 回合～",
-            stop: "猜数字比赛已停止",
-            outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！",
-            tooSmall: "猜小啦！当前范围更新为 [{0}-{1}]",
-            tooBig: "猜大啦！当前范围更新为 [{0}-{1}]",
-            correct: "恭喜你猜中数字！本轮你不得分，其他参与者各得1分～",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 猜数字比赛结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "猜数字功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        wzHero: {
-            start: "猜王者英雄开始！本次共 {0} 回合～",
-            startUsage: "用法错误！正确用法：猜王者英雄 开始 [难度] | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束",
-            stop: "猜王者英雄比赛已停止",
-            notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 [难度] 开始游戏",
-            hint: "提示",
-            apiError: "API请求失败，请稍后再试",
-            correct: "答对啦！你获得1分～",
-            wrong: "答错啦～正确答案是：{0}，你不得分",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 猜王者英雄比赛结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "猜王者英雄功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        chengyuImage: {
-            start: "看图猜成语比赛开始！本次共 {0} 回合～",
-            stop: "看图猜成语比赛已停止",
-            submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
-            notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
-            next: "第 {0} 题来啦！",
-            hintGet: "【提示】{0}",
-            hintError: "获取提示失败，请稍后再试",
-            apiError: "API请求失败，请稍后再试",
-            correct: "答对啦！你获得1分～",
-            wrong: "答错啦～正确答案是：{0}，你不得分",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 看图猜成语比赛结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "看图猜成语功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        chengyuJielong: {
-            start: "成语接龙比赛开始！本次共 {0} 回合～我先来～",
-            stop: "成语接龙比赛已停止",
-            notStarted: "成语接龙比赛尚未开始，请输入 成语接龙 开始 开始游戏",
-            joinUsage: "请直接发送 成语接龙 [成语] 参与接龙",
-            apiError: "API请求失败，请稍后再试",
-            botTurn: "该我了！我接：{0}（{1}）\n释义：{2}",
-            botWin: "哈哈我接不上了！本轮结束～",
-            autoPlayTooMany: "我已经主动参与 {0} 次啦，不再主动接啦～",
-            gameInactiveStop: "太久没人玩啦，比赛自动结束～",
-            notIdiom: "请发送四字成语参与游戏～",
-            correct: "接龙成功！你获得1分～",
-            wrong: "接龙失败！你不得分，其他参与者各得1分～",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 成语接龙比赛结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            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} 回合～",
-            stop: "算24点游戏已停止",
-            notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
-            generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
-            correct: "答对啦！你获得1分～",
-            wrong: "答错啦～",
-            impossible: "这组数无法算出24！本题作废，换一组数字～",
-            solved: "这组数已经被答对啦，换一组数字～",
-            roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 算24点游戏结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "算24点功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        passwordLock: {
-            start: "猜密码游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
-            stop: "猜密码游戏已停止",
-            notStarted: "猜密码游戏尚未开始，请输入 猜密码 开始 开始游戏",
-            guess: "你猜测的密码是：{0}，这是第 {1} 次猜测",
-            correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～",
-            wrong: "密码错误！{0}",
-            solved: "密码已经被猜出来啦，游戏结束～",
-            noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
-            invalidPassword: "无效的密码！请输入4位数字",
-            gameEnd: "🎉 猜密码游戏结束！🎉",
-            rankTitle: "🏆 排行榜 🏆",
-            rankEmpty: "暂无参与记录～",
-            disabled: "猜密码功能已关闭，请联系管理员开启",
-            autoStop: "游戏因长时间无人操作，已自动结束"
-        },
-        common: {
-            gameRunning: "当前已有游戏在运行中，请先结束当前游戏后再开始新游戏！",
-            gameStoppedByInactive: "游戏因长时间无人操作，已自动结束",
-            paramError: "参数错误！请检查输入格式"
-        }
+        guessNumber: cfg.guessNumber.messages,
+        wzHero: cfg.wzHero.messages,
+        chengyuImage: cfg.chengyuImage.messages,
+        chengyuJielong: cfg.chengyuJielong.messages,
+        calc24: cfg.calc24.messages,
+        common: cfg.commonMessages
     };
     try {
         const p = path_1.default.join(__dirname, './locales/zh-CN.yml');
@@ -613,7 +530,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);
@@ -623,11 +540,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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
             return;
         }
         st.chengyuJielong.hasTriggeredAutoPlay = true;
@@ -661,7 +578,7 @@ function apply(ctx, cfg) {
                     await session.send(m);
                     await session.send(d.chengyuJielong.gameEnd);
                     if (cfg.chengyuJielong.showRank && !isPrivate(session)) {
-                        const rankText = generateRankText(st.chengyuJielong.players);
+                        const rankText = generateRankText(st.chengyuJielong.players, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
                         await session.send(rankText);
                     }
                     clearGameData(st.chengyuJielong);
@@ -678,7 +595,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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
     };
     ctx.middleware(async (session, next) => {
         if (!session.content)
@@ -697,7 +614,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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
                 scheduleAutoPlay(session, key, st);
                 return next();
             }
@@ -738,7 +655,7 @@ function apply(ctx, cfg) {
                         await session.send(m);
                         await session.send(d.chengyuJielong.gameEnd);
                         if (cfg.chengyuJielong.showRank && !isPrivate(session)) {
-                            const rankText = generateRankText(st.chengyuJielong.players);
+                            const rankText = generateRankText(st.chengyuJielong.players, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
                             await session.send(rankText);
                         }
                         clearGameData(st.chengyuJielong);
@@ -747,7 +664,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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
                         scheduleAutoPlay(session, key, st);
                     }
                 }
@@ -760,7 +677,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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
                 scheduleAutoPlay(session, key, st);
             }
             gameStates.set(key, st);
@@ -778,7 +695,7 @@ function apply(ctx, cfg) {
                         params: {
                             action: 'get_hint',
                             id: st.chengyuImage.currentId,
-                            level: 1
+                            level: cfg.chengyuImage.defaultHintLevel
                         },
                         timeout: cfg.apiConfig.timeout
                     });
@@ -793,11 +710,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, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
                 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, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
                 return next();
             }
             try {
@@ -823,7 +740,7 @@ function apply(ctx, cfg) {
                             await session.send(reply);
                             await session.send(d.chengyuImage.gameEnd);
                             if (cfg.chengyuImage.showRank && !isPrivate(session)) {
-                                const rankText = generateRankText(st.chengyuImage.players);
+                                const rankText = generateRankText(st.chengyuImage.players, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
                                 await session.send(rankText);
                             }
                             clearGameData(st.chengyuImage);
@@ -853,7 +770,7 @@ function apply(ctx, cfg) {
                                 st.chengyuImage.started = false;
                                 clearGameTimer(st.chengyuImage);
                                 if (cfg.chengyuImage.showRank && !isPrivate(session)) {
-                                    const rankText = generateRankText(st.chengyuImage.players);
+                                    const rankText = generateRankText(st.chengyuImage.players, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
                                     await session.send(rankText);
                                 }
                                 clearGameData(st.chengyuImage);
@@ -873,7 +790,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, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
             gameStates.set(key, st);
             return;
         }
@@ -884,7 +801,7 @@ function apply(ctx, cfg) {
                 st.wzHero.participants.push(playerKey);
             }
             if (content === '结束') {
-                clearGameData(st.wzHero);
+                clearGameData(st.wzHero, cfg.wzHero.showRank && !isPrivate(session), session, d.wzHero.rankTitle, d.wzHero.rankEmpty);
                 await session.send(d.wzHero.stop);
                 gameStates.set(key, st);
                 return;
@@ -908,7 +825,7 @@ function apply(ctx, cfg) {
                             await session.send(text);
                             await session.send(d.wzHero.gameEnd);
                             if (cfg.wzHero.showRank && !isPrivate(session)) {
-                                const rankText = generateRankText(st.wzHero.players);
+                                const rankText = generateRankText(st.wzHero.players, d.wzHero.rankTitle, d.wzHero.rankEmpty);
                                 await session.send(rankText);
                             }
                             clearGameData(st.wzHero);
@@ -941,7 +858,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, d.wzHero.rankTitle, d.wzHero.rankEmpty);
             gameStates.set(key, st);
             return;
         }
@@ -952,14 +869,14 @@ function apply(ctx, cfg) {
                 st.guessNumber.participants.push(playerKey);
             }
             if (content === '结束') {
-                clearGameData(st.guessNumber);
+                clearGameData(st.guessNumber, cfg.guessNumber.showRank && !isPrivate(session), session, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
                 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, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
                 return next();
             }
             if (num === st.guessNumber.target) {
@@ -971,7 +888,7 @@ function apply(ctx, cfg) {
                     clearGameTimer(st.guessNumber);
                     await session.send(d.guessNumber.gameEnd);
                     if (cfg.guessNumber.showRank && !isPrivate(session)) {
-                        const rankText = generateRankText(st.guessNumber.players);
+                        const rankText = generateRankText(st.guessNumber.players, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
                         await session.send(rankText);
                     }
                     clearGameData(st.guessNumber);
@@ -990,108 +907,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 === '结束') {
-                clearGameData(st.dice);
-                await session.send(d.dice.stop);
-                gameStates.set(key, st);
-                return;
-            }
-            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 = koishi_1.Random.int(1, 6);
-            let resultMsg = d.dice.roll.replace('{0}', st.dice.playerDice.toString()).replace('{1}', st.dice.botDice.toString());
-            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;
-            }
-            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 (content === '结束') {
-                clearGameData(st.rps);
-                await session.send(d.rps.stop);
-                gameStates.set(key, st);
-                return;
-            }
-            if (!st.rps.choices.includes(content)) {
-                await session.send(d.rps.invalidChoice);
-                setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
-                return;
-            }
-            st.rps.playerChoice = content;
-            st.rps.botChoice = 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 ((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;
-            }
-            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, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
             gameStates.set(key, st);
             return;
         }
@@ -1102,152 +918,61 @@ function apply(ctx, cfg) {
                 st.calc24.participants.push(playerKey);
             }
             if (content === '结束') {
-                clearGameData(st.calc24);
+                clearGameData(st.calc24, cfg.calc24.showRank && !isPrivate(session), session, d.calc24.rankTitle, d.calc24.rankEmpty);
                 await session.send(d.calc24.stop);
                 gameStates.set(key, st);
                 return;
             }
             if (content === '换题') {
                 if (!st.calc24.solved) {
-                    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]));
-                    }
+                    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;
-                    const canCalculate = calculate24([...st.calc24.numbers]);
-                    if (!canCalculate) {
-                        await session.send(d.calc24.impossible);
-                    }
-                    else {
-                        await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-                    }
+                    await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString())
+                        .replace('{1}', st.calc24.difficulty)
+                        .replace('{2}', st.calc24.numbers.join('、')));
                 }
-                setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+                setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank, d.calc24.rankTitle, d.calc24.rankEmpty);
                 return;
             }
             if (st.calc24.solved) {
                 await session.send(d.calc24.solved);
-                setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+                setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank, d.calc24.rankTitle, d.calc24.rankEmpty);
                 return;
             }
-            st.calc24.playerAnswer = content;
-            const canCalculate = calculate24([...st.calc24.numbers]);
-            if (!canCalculate) {
-                await session.send(d.calc24.impossible);
-                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.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-            }
-            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;
-                        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);
-                        }
-                        else {
-                            await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
-                            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]));
-                            }
-                            st.calc24.solved = false;
-                            const nextCanCalculate = calculate24([...st.calc24.numbers]);
-                            if (!nextCanCalculate) {
-                                await session.send(d.calc24.impossible);
-                            }
-                            else {
-                                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-                            }
-                        }
-                    }
-                    else {
-                        await session.send(d.calc24.wrong);
-                    }
-                }
-                catch {
-                    await session.send(d.calc24.wrong);
-                }
-            }
-            setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
-            gameStates.set(key, st);
-            return;
-        }
-        if (cfg.enablePasswordLock && st.passwordLock.started) {
-            clearGameTimer(st.passwordLock);
-            if (!st.passwordLock.players[playerKey]) {
-                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, 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;
-            }
-            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) {
-                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].correctCount += 1;
-                st.passwordLock.solved = true;
-                st.passwordLock.started = false;
-                clearGameTimer(st.passwordLock);
-                await session.send(d.passwordLock.gameEnd);
-                if (cfg.passwordLock.showRank && !isPrivate(session)) {
-                    const rankText = generateRankText(st.passwordLock.players);
-                    await session.send(rankText);
-                }
-                clearGameData(st.passwordLock);
-            }
-            else {
-                let hint = '';
-                if (cfg.passwordLock.showHint) {
-                    hint = generatePasswordHint(st.passwordLock.password, content);
-                }
-                if (st.passwordLock.guessTimes >= st.passwordLock.maxGuessTimes) {
-                    await session.send(d.passwordLock.noChance.replace('{0}', st.passwordLock.password));
-                    st.passwordLock.started = false;
-                    clearGameTimer(st.passwordLock);
-                    await session.send(d.passwordLock.gameEnd);
-                    if (cfg.passwordLock.showRank && !isPrivate(session)) {
-                        const rankText = generateRankText(st.passwordLock.players);
+            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, d.calc24.rankTitle, d.calc24.rankEmpty);
                         await session.send(rankText);
                     }
-                    clearGameData(st.passwordLock);
+                    clearGameData(st.calc24);
                 }
                 else {
-                    await session.send(d.passwordLock.wrong.replace('{0}', hint));
-                    await session.send(`剩余猜测次数：${st.passwordLock.maxGuessTimes - st.passwordLock.guessTimes}`);
+                    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('、')));
                 }
             }
-            setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+            else {
+                await session.send(d.calc24.wrong);
+            }
+            setupAutoStop(session, st.calc24, cfg, 'calc24', d.calc24.autoStop, cfg.calc24.showRank, d.calc24.rankTitle, d.calc24.rankEmpty);
             gameStates.set(key, st);
             return;
         }
@@ -1273,10 +998,10 @@ 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, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
         }
         else if (action === '结束') {
-            clearGameData(st.guessNumber);
+            clearGameData(st.guessNumber, cfg.guessNumber.showRank && !isPrivate(session), session, d.guessNumber.rankTitle, d.guessNumber.rankEmpty);
             await session.send(d.guessNumber.stop);
             gameStates.set(key, st);
         }
@@ -1297,7 +1022,7 @@ function apply(ctx, cfg) {
         }
         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', {
@@ -1307,7 +1032,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 || '';
             }
@@ -1315,10 +1040,10 @@ 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, d.wzHero.rankTitle, d.wzHero.rankEmpty);
         }
         else if (action === '结束') {
-            clearGameData(st.wzHero);
+            clearGameData(st.wzHero, cfg.wzHero.showRank && !isPrivate(session), session, d.wzHero.rankTitle, d.wzHero.rankEmpty);
             await session.send(d.wzHero.stop);
             gameStates.set(key, st);
         }
@@ -1351,7 +1076,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));
                 }
@@ -1363,10 +1088,10 @@ 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, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
         }
         else if (action === '结束') {
-            clearGameData(st.chengyuImage);
+            clearGameData(st.chengyuImage, cfg.chengyuImage.showRank && !isPrivate(session), session, d.chengyuImage.rankTitle, d.chengyuImage.rankEmpty);
             await session.send(d.chengyuImage.stop);
             gameStates.set(key, st);
         }
@@ -1393,10 +1118,10 @@ 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, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
         }
         else if (action === '结束') {
-            clearGameData(st.chengyuJielong);
+            clearGameData(st.chengyuJielong, cfg.chengyuJielong.showRank && !isPrivate(session), session, d.chengyuJielong.rankTitle, d.chengyuJielong.rankEmpty);
             await session.send(d.chengyuJielong.stop);
             gameStates.set(key, st);
         }
@@ -1404,60 +1129,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, 'dice')) {
-            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);
-        }
-        else {
-            await session.send('请输入：掷骰子 开始 或 掷骰子 结束');
-        }
-    });
-    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, 'rps')) {
-            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);
-        }
-        else {
-            await session.send('请输入：石头剪刀布 开始 或 石头剪刀布 结束');
-        }
-    });
     ctx.command('算24点 <action>', '算24点游戏')
         .action(async (argv, action) => {
         const session = argv.session;
@@ -1470,26 +1141,22 @@ function apply(ctx, cfg) {
             return;
         }
         if (action === '开始') {
+            st.calc24.difficulty = cfg.calc24.defaultDifficulty;
             st.calc24.started = true;
             st.calc24.currentRound = 1;
             st.calc24.solved = false;
-            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()));
-            const canCalculate = calculate24([...st.calc24.numbers]);
-            if (!canCalculate) {
-                await session.send(d.calc24.impossible);
-            }
-            else {
-                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-            }
+            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, d.calc24.rankTitle, d.calc24.rankEmpty);
         }
         else if (action === '结束') {
-            clearGameData(st.calc24);
+            clearGameData(st.calc24, cfg.calc24.showRank && !isPrivate(session), session, d.calc24.rankTitle, d.calc24.rankEmpty);
             await session.send(d.calc24.stop);
             gameStates.set(key, st);
         }
@@ -1497,34 +1164,4 @@ function apply(ctx, cfg) {
             await session.send('请输入：算24点 开始 或 算24点 结束');
         }
     });
-    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, 'passwordLock')) {
-            await session.send(d.common.gameRunning);
-            return;
-        }
-        if (action === '开始') {
-            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);
-        }
-        else if (action === '结束') {
-            clearGameData(st.passwordLock);
-            await session.send(d.passwordLock.stop);
-            gameStates.set(key, st);
-        }
-        else {
-            await session.send('请输入：猜密码 开始 或 猜密码 结束');
-        }
-    });
 }