koishi-plugin-game-mini 0.2.2 → 0.2.3

package/lib/index.js

@@ -15,109 +15,189 @@ exports.using = ['i18n'];
 exports.inject = ['console'];
 exports.Config = koishi_1.Schema.object({
     enableNumberGuess: koishi_1.Schema.boolean().default(true)
-        .description('是否启用猜数字游戏')
+        .description('启用猜数字游戏')
         .i18n({ 'zh-CN': '启用猜数字游戏' }),
     enableWzHero: koishi_1.Schema.boolean().default(true)
-        .description('是否启用王者英雄猜谜游戏')
-        .i18n({ 'zh-CN': '启用王者英雄猜谜' }),
+        .description('启用王者英雄猜谜游戏')
+        .i18n({ 'zh-CN': '启用王者英雄猜谜游戏' }),
     enableChengyuImage: koishi_1.Schema.boolean().default(true)
-        .description('是否启用看图猜成语游戏')
-        .i18n({ 'zh-CN': '启用看图猜成语' }),
+        .description('启用看图猜成语游戏')
+        .i18n({ 'zh-CN': '启用看图猜成语游戏' }),
     enableChengyuJielong: koishi_1.Schema.boolean().default(true)
-        .description('是否启用成语接龙游戏')
-        .i18n({ 'zh-CN': '启用成语接龙' }),
+        .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('是否允许私聊玩游戏')
+        .description('允许私聊玩游戏')
         .i18n({ 'zh-CN': '允许私聊玩游戏' }),
     autoPlayDelay: koishi_1.Schema.number().min(0).default(10)
-        .description('成语接龙机器人自动接龙延迟（秒）')
-        .i18n({ 'zh-CN': '机器人自动接龙延迟(秒)' }),
+        .description('机器人自动操作延迟（秒）')
+        .i18n({ 'zh-CN': '机器人自动操作延迟（秒）' }),
     autoPlayMaxCount: koishi_1.Schema.number().min(1).default(5)
-        .description('成语接龙机器人最大自动接龙次数')
-        .i18n({ 'zh-CN': '机器人最大自动接龙次数' }),
+        .description('机器人最大自动操作次数')
+        .i18n({ 'zh-CN': '机器人最大自动操作次数' }),
     autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30)
         .description('游戏无操作自动停止时间（秒）')
-        .i18n({ 'zh-CN': '无操作自动停止时间(秒)' }),
+        .i18n({ 'zh-CN': '游戏无操作自动停止时间（秒）' }),
     guessNumber: koishi_1.Schema.object({
         min: koishi_1.Schema.number().min(0).default(0)
             .description('猜数字最小值')
-            .i18n({ 'zh-CN': '最小值' }),
+            .i18n({ 'zh-CN': '猜数字最小值' }),
         max: koishi_1.Schema.number().min(1).default(100)
             .description('猜数字最大值')
-            .i18n({ 'zh-CN': '最大值' }),
+            .i18n({ 'zh-CN': '猜数字最大值' }),
         botParticipateInGroup: koishi_1.Schema.boolean().default(true)
-            .description('群聊中机器人是否参与猜数字')
-            .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
+            .description('群聊中机器人参与猜数字')
+            .i18n({ 'zh-CN': '群聊中机器人参与猜数字' }),
         totalRounds: koishi_1.Schema.number().min(1).default(10)
             .description('猜数字总回合数')
-            .i18n({ 'zh-CN': '总回合数' }),
+            .i18n({ 'zh-CN': '猜数字总回合数' }),
         showRank: koishi_1.Schema.boolean().default(true)
-            .description('游戏结束后是否显示排行榜')
-            .i18n({ 'zh-CN': '显示排行榜' }),
+            .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': '总回合数' }),
+            .i18n({ 'zh-CN': '王者英雄猜谜总回合数' }),
         showRank: koishi_1.Schema.boolean().default(true)
-            .description('游戏结束后是否显示排行榜')
-            .i18n({ 'zh-CN': '显示排行榜' }),
+            .description('王者英雄猜谜显示排行榜')
+            .i18n({ 'zh-CN': '王者英雄猜谜显示排行榜' }),
     }).description('王者英雄猜谜游戏配置')
-        .i18n({ 'zh-CN': '王者英雄猜谜配置' }),
+        .i18n({ 'zh-CN': '王者英雄猜谜游戏配置' }),
     chengyuImage: koishi_1.Schema.object({
         totalRounds: koishi_1.Schema.number().min(1).default(10)
             .description('看图猜成语总回合数')
-            .i18n({ 'zh-CN': '总回合数' }),
+            .i18n({ 'zh-CN': '看图猜成语总回合数' }),
         showRank: koishi_1.Schema.boolean().default(true)
-            .description('游戏结束后是否显示排行榜')
-            .i18n({ 'zh-CN': '显示排行榜' }),
+            .description('看图猜成语显示排行榜')
+            .i18n({ 'zh-CN': '看图猜成语显示排行榜' }),
     }).description('看图猜成语游戏配置')
-        .i18n({ 'zh-CN': '看图猜成语配置' }),
+        .i18n({ 'zh-CN': '看图猜成语游戏配置' }),
     chengyuJielong: koishi_1.Schema.object({
         botParticipateInGroup: koishi_1.Schema.boolean().default(true)
-            .description('群聊中机器人是否参与成语接龙')
-            .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
+            .description('群聊中机器人参与成语接龙')
+            .i18n({ 'zh-CN': '群聊中机器人参与成语接龙' }),
         totalRounds: koishi_1.Schema.number().min(1).default(10)
             .description('成语接龙总回合数')
-            .i18n({ 'zh-CN': '总回合数' }),
+            .i18n({ 'zh-CN': '成语接龙总回合数' }),
         showRank: koishi_1.Schema.boolean().default(true)
-            .description('游戏结束后是否显示排行榜')
-            .i18n({ 'zh-CN': '显示排行榜' }),
+            .description('成语接龙显示排行榜')
+            .i18n({ 'zh-CN': '成语接龙显示排行榜' }),
     }).description('成语接龙游戏配置')
-        .i18n({ 'zh-CN': '成语接龙配置' }),
+        .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': '请求超时时间(毫秒)' }),
+            .i18n({ 'zh-CN': 'API请求超时时间（毫秒）' }),
     }).description('API接口配置')
         .i18n({ 'zh-CN': 'API接口配置' }),
 }).i18n({
     'zh-CN': {
         'enableNumberGuess': '启用猜数字游戏',
-        'enableWzHero': '启用王者英雄猜谜',
-        'enableChengyuImage': '启用看图猜成语',
-        'enableChengyuJielong': '启用成语接龙',
+        'enableWzHero': '启用王者英雄猜谜游戏',
+        'enableChengyuImage': '启用看图猜成语游戏',
+        'enableChengyuJielong': '启用成语接龙游戏',
+        'enableDice': '启用掷骰子比大小游戏',
+        'enableRps': '启用石头剪刀布游戏',
+        'enableCalc24': '启用算24点游戏',
+        'enablePasswordLock': '启用密码锁破解游戏',
         'enablePrivateGame': '允许私聊玩游戏',
-        'autoPlayDelay': '机器人自动接龙延迟(秒)',
-        'autoPlayMaxCount': '机器人最大自动接龙次数',
-        'autoStopInactiveTime': '无操作自动停止时间(秒)',
+        'autoPlayDelay': '机器人自动操作延迟（秒）',
+        'autoPlayMaxCount': '机器人最大自动操作次数',
+        'autoStopInactiveTime': '游戏无操作自动停止时间（秒）',
         'guessNumber': '猜数字游戏配置',
-        'guessNumber.min': '最小值',
-        'guessNumber.max': '最大值',
-        'guessNumber.botParticipateInGroup': '机器人参与群聊游戏',
-        'guessNumber.totalRounds': '总回合数',
-        'guessNumber.showRank': '显示排行榜',
+        'guessNumber.min': '猜数字最小值',
+        'guessNumber.max': '猜数字最大值',
+        'guessNumber.botParticipateInGroup': '群聊中机器人参与猜数字',
+        'guessNumber.totalRounds': '猜数字总回合数',
+        'guessNumber.showRank': '猜数字显示排行榜',
         'wzHero': '王者英雄猜谜配置',
-        'wzHero.totalRounds': '总回合数',
-        'wzHero.showRank': '显示排行榜',
+        'wzHero.totalRounds': '王者英雄猜谜总回合数',
+        'wzHero.showRank': '王者英雄猜谜显示排行榜',
         'chengyuImage': '看图猜成语配置',
-        'chengyuImage.totalRounds': '总回合数',
-        'chengyuImage.showRank': '显示排行榜',
+        'chengyuImage.totalRounds': '看图猜成语总回合数',
+        'chengyuImage.showRank': '看图猜成语显示排行榜',
         'chengyuJielong': '成语接龙配置',
-        'chengyuJielong.botParticipateInGroup': '机器人参与群聊游戏',
-        'chengyuJielong.totalRounds': '总回合数',
-        'chengyuJielong.showRank': '显示排行榜',
+        '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': '请求超时时间(毫秒)'
     }
@@ -149,6 +229,14 @@ 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) => {
@@ -160,6 +248,10 @@ const clearAllTimers = (st) => {
     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);
 };
@@ -209,8 +301,49 @@ const initState = (key, c) => {
             botTurn: true,
             autoPlayCount: 0,
             hasTriggeredAutoPlay: false,
-            lastActiveTime: Date.now()
+            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: ['石头', '剪刀', '布']
+        },
+        calc24: {
+            started: false,
+            totalRounds: c.calc24.totalRounds,
+            currentRound: 0,
+            players: {},
+            participants: [],
+            numbers: [],
+            playerAnswer: ''
+        },
+        passwordLock: {
+            started: false,
+            totalRounds: 1,
+            currentRound: 0,
+            players: {},
+            participants: [],
+            password: '',
+            playerGuess: '',
+            guessTimes: 0,
+            maxGuessTimes: c.passwordLock.maxGuessTimes,
+            hints: []
+        }
     };
     gameStates.set(key, s);
     return s;
@@ -257,10 +390,67 @@ const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
         }
     }, cfg.autoStopInactiveTime * 1000);
 };
+const calculate24 = (numbers) => {
+    if (numbers.length === 1)
+        return Math.abs(numbers[0] - 24) < 0.001;
+    for (let i = 0; i < numbers.length; i++) {
+        for (let j = 0; j < numbers.length; j++) {
+            if (i === j)
+                continue;
+            const rest = [];
+            for (let k = 0; k < numbers.length; k++) {
+                if (k !== i && k !== j)
+                    rest.push(numbers[k]);
+            }
+            const a = numbers[i];
+            const b = numbers[j];
+            if (calculate24([...rest, a + b]))
+                return true;
+            if (calculate24([...rest, a - b]))
+                return true;
+            if (calculate24([...rest, b - a]))
+                return true;
+            if (calculate24([...rest, a * b]))
+                return true;
+            if (b !== 0 && calculate24([...rest, a / b]))
+                return true;
+            if (a !== 0 && calculate24([...rest, b / a]))
+                return true;
+        }
+    }
+    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;
+        }
+    }
+    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 `提示：${correctPos}个数字位置正确，${correctNum}个数字正确但位置错误`;
+};
 function apply(ctx, cfg) {
     const d = {
         guessNumber: {
-            usage: "用法错误！正确用法：guess start/stop 或 直接输入数字",
+            usage: "用法错误！正确用法：猜数字 开始 | 猜数字 [数字] | 猜数字 结束",
             start: "猜数字比赛开始！本次共 {0} 回合～",
             stop: "猜数字比赛已停止",
             outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！",
@@ -276,9 +466,9 @@ function apply(ctx, cfg) {
         },
         wzHero: {
             start: "王者英雄猜谜开始！本次共 {0} 回合～",
-            startUsage: "用法错误！正确用法：wzhero start [难度] 开始游戏",
+            startUsage: "用法错误！正确用法：王者英雄 开始 [难度] | 王者英雄 [答案] | 王者英雄 提示 | 王者英雄 结束",
             stop: "王者英雄猜谜比赛已停止",
-            notStarted: "王者英雄猜谜比赛尚未开始，请输入 wzhero start [难度] 开始游戏",
+            notStarted: "王者英雄猜谜比赛尚未开始，请输入 王者英雄 开始 [难度] 开始游戏",
             hint: "提示",
             apiError: "API请求失败，请稍后再试",
             correct: "答对啦！你获得1分～",
@@ -293,8 +483,8 @@ function apply(ctx, cfg) {
         chengyuImage: {
             start: "看图猜成语比赛开始！本次共 {0} 回合～",
             stop: "看图猜成语比赛已停止",
-            submitUsage: "请直接输入你猜测的成语，或输入 提示 获取线索",
-            notStarted: "看图猜成语比赛尚未开始，请输入 cyimage start 开始游戏",
+            submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
+            notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
             next: "第 {0} 题来啦！",
             hintGet: "【提示】{0}",
             hintError: "获取提示失败，请稍后再试",
@@ -311,8 +501,8 @@ function apply(ctx, cfg) {
         chengyuJielong: {
             start: "成语接龙比赛开始！本次共 {0} 回合～我先来～",
             stop: "成语接龙比赛已停止",
-            notStarted: "成语接龙比赛尚未开始，请输入 cyjl start 开始游戏",
-            joinUsage: "请直接发送四字成语参与接龙",
+            notStarted: "成语接龙比赛尚未开始，请输入 成语接龙 开始 开始游戏",
+            joinUsage: "请直接发送 成语接龙 [成语] 参与接龙",
             apiError: "API请求失败，请稍后再试",
             botTurn: "该我了！我接：{0}（{1}）\n释义：{2}",
             botWin: "哈哈我接不上了！本轮结束～",
@@ -328,6 +518,67 @@ 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} 回合～",
+            stop: "算24点游戏已停止",
+            notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
+            generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
+            correct: "答对啦！你获得1分～",
+            wrong: "答错啦～这组数可以算出24哦！",
+            impossible: "这组数无法算出24！本轮作废～",
+            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}",
+            noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
+            invalidPassword: "无效的密码！请输入4位数字",
+            gameEnd: "🎉 密码锁破解游戏结束！🎉",
+            rankTitle: "🏆 排行榜 🏆",
+            rankEmpty: "暂无参与记录～",
+            disabled: "密码锁破解功能已关闭，请联系管理员开启",
+            autoStop: "游戏因长时间无人操作，已自动结束"
+        },
         common: {
             gameRunning: "当前已有游戏在运行中，请先结束当前游戏后再开始新游戏！",
             gameStoppedByInactive: "游戏因长时间无人操作，已自动结束",
@@ -522,7 +773,8 @@ function apply(ctx, cfg) {
                     const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
                         params: {
                             action: 'get_hint',
-                            id: st.chengyuImage.currentId
+                            id: st.chengyuImage.currentId,
+                            level: 1
                         },
                         timeout: cfg.apiConfig.timeout
                     });
@@ -587,7 +839,7 @@ function apply(ctx, cfg) {
                                 st.chengyuImage.currentId = nextDt.data.question.id;
                                 st.chengyuImage.currentPage = nextDt.data.question.page;
                                 st.chengyuImage.options = nextDt.data.question.options;
-                                st.chengyuImage.answer = nextDt.data.question.answer;
+                                st.chengyuImage.answer = nextDt.data.question.answer || '';
                                 await session.send(d.chengyuImage.next.replace('{0}', st.chengyuImage.currentRound.toString()));
                                 await session.send(`请从选项中选择4个字组成成语\n选项：${nextDt.data.question.options.join('、')}`);
                                 await session.send(koishi_1.segment.image(nextDt.data.question.image_url));
@@ -605,7 +857,8 @@ function apply(ctx, cfg) {
                         }
                     }
                     else {
-                        reply = d.chengyuImage.wrong.replace('{0}', st.chengyuImage.answer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
+                        const correctAnswer = dt.data?.correct_answer || st.chengyuImage.answer;
+                        reply = d.chengyuImage.wrong.replace('{0}', correctAnswer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
                         await session.send(reply);
                     }
                 }
@@ -714,251 +967,483 @@ function apply(ctx, cfg) {
                 }
             }
             else if (num < st.guessNumber.target) {
-                await session.send(d.guessNumber.tooSmall.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
+                st.guessNumber.currentMin = num + 1;
+                await session.send(d.guessNumber.tooSmall.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
             }
             else {
-                await session.send(d.guessNumber.tooBig.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMin.toString()));
+                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;
         }
-        return next();
-    });
-    if (cfg.enableWzHero) {
-        ctx.command('wzhero <action:string> [difficulty:string]')
-            .action(async (argv, action, difficulty) => {
-            const s = argv.session;
-            if (!s)
-                return '';
-            const key = getSessionKey(s);
-            const st = gameStates.get(key) || initState(key, cfg);
-            if (action === 'start') {
-                if (checkGameRunning(st, 'wzHero')) {
-                    s.send(d.common.gameRunning);
-                    return '';
-                }
-                const fd = difficulty || '中等';
-                if (!['简单', '中等', '困难'].includes(fd)) {
-                    await s.send(d.wzHero.startUsage);
-                    return '';
-                }
-                st.wzHero.started = true;
-                st.wzHero.difficulty = fd;
-                st.wzHero.totalRounds = cfg.wzHero.totalRounds;
-                st.wzHero.currentRound = 1;
-                st.wzHero.players = {};
-                st.wzHero.participants = [];
-                gameStates.set(key, st);
-                try {
-                    const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
-                        params: { id: getIntUserId(s), msg: `开始游戏${fd}` }, timeout: cfg.apiConfig.timeout
-                    });
-                    const dt = r.data;
-                    if (dt.status === 'success') {
-                        let t = `${dt.message}\n${dt.hint}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide}`;
-                        t = t.replace(/\\n/g, '\n');
-                        t = d.wzHero.start.replace('{0}', cfg.wzHero.totalRounds.toString()) + '\n' + t;
-                        st.wzHero.currentAnswer = dt.hint || '';
-                        await s.send(t);
-                        setupAutoStop(s, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
-                    }
-                    else {
-                        await s.send(dt.message || '开始失败');
-                    }
+        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;
                 }
-                catch (error) {
-                    await s.send(d.wzHero.apiError);
-                    st.wzHero.started = false;
+                else if (st.dice.playerDice < st.dice.botDice) {
+                    resultMsg += '\n' + d.dice.lose;
+                }
+                else {
+                    resultMsg += '\n' + d.dice.draw;
                 }
             }
-            else if (action === 'stop') {
-                st.wzHero.started = false;
-                clearGameTimer(st.wzHero);
-                await s.send(d.wzHero.stop);
-                if (cfg.wzHero.showRank && !isPrivate(s)) {
-                    const rankText = generateRankText(st.wzHero.players);
-                    await s.send(rankText);
+            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.wzHero);
-                gameStates.set(key, st);
+                clearGameData(st.dice);
             }
             else {
-                await s.send(d.wzHero.startUsage);
+                await session.send(d.dice.roundEnd.replace('{0}', st.dice.currentRound.toString()).replace('{1}', (st.dice.totalRounds - st.dice.currentRound).toString()));
             }
-            return '';
-        });
-    }
-    if (cfg.enableChengyuImage) {
-        ctx.command('cyimage <action:string>')
-            .action(async (argv, action) => {
-            const s = argv.session;
-            if (!s)
-                return '';
-            const key = getSessionKey(s);
-            const st = gameStates.get(key) || initState(key, cfg);
-            if (action === 'start') {
-                if (checkGameRunning(st, 'chengyuImage')) {
-                    s.send(d.common.gameRunning);
-                    return '';
-                }
-                st.chengyuImage.started = true;
-                st.chengyuImage.totalRounds = cfg.chengyuImage.totalRounds;
-                st.chengyuImage.currentRound = 1;
-                st.chengyuImage.players = {};
-                st.chengyuImage.participants = [];
-                try {
-                    const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
-                        params: { action: 'get_question' }, timeout: cfg.apiConfig.timeout
-                    });
-                    const dt = r.data;
-                    if (dt.success) {
-                        st.chengyuImage.currentId = dt.data.question.id;
-                        st.chengyuImage.currentPage = dt.data.question.page;
-                        st.chengyuImage.options = dt.data.question.options;
-                        st.chengyuImage.answer = dt.data.question.answer;
-                        gameStates.set(key, st);
-                        await s.send(d.chengyuImage.start.replace('{0}', cfg.chengyuImage.totalRounds.toString()));
-                        await s.send(`第 1 题来啦！\n请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
-                        await s.send(koishi_1.segment.image(dt.data.question.image_url));
-                        setupAutoStop(s, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
-                    }
-                    else {
-                        await s.send('获取题目失败，请稍后再试');
-                        st.chengyuImage.started = false;
-                    }
+            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;
                 }
-                catch (error) {
-                    await s.send(d.chengyuImage.apiError);
-                    st.chengyuImage.started = false;
+                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;
             }
-            else if (action === 'stop') {
-                st.chengyuImage.started = false;
-                clearGameTimer(st.chengyuImage);
-                await s.send(d.chengyuImage.stop);
-                if (cfg.chengyuImage.showRank && !isPrivate(s)) {
-                    const rankText = generateRankText(st.chengyuImage.players);
-                    await s.send(rankText);
+            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.chengyuImage);
-                gameStates.set(key, st);
+                clearGameData(st.rps);
             }
             else {
-                await s.send(d.chengyuImage.notStarted);
+                await session.send(d.rps.roundEnd.replace('{0}', st.rps.currentRound.toString()).replace('{1}', (st.rps.totalRounds - st.rps.currentRound).toString()));
             }
-            return '';
-        });
-    }
-    if (cfg.enableChengyuJielong) {
-        ctx.command('cyjl <action:string>')
-            .action(async (argv, a) => {
-            const s = argv.session;
-            if (!s)
-                return '';
-            if (isPrivate(s) && !cfg.enablePrivateGame)
-                return '';
-            const key = getSessionKey(s);
-            const st = gameStates.get(key) || initState(key, cfg);
-            if (a === 'start') {
-                if (checkGameRunning(st, 'chengyuJielong')) {
-                    s.send(d.common.gameRunning);
-                    return '';
-                }
-                st.chengyuJielong.started = true;
-                st.chengyuJielong.totalRounds = cfg.chengyuJielong.totalRounds;
-                st.chengyuJielong.currentRound = 1;
-                st.chengyuJielong.botTurn = true;
-                st.chengyuJielong.autoPlayCount = 0;
-                st.chengyuJielong.hasTriggeredAutoPlay = false;
-                st.chengyuJielong.players = {};
-                st.chengyuJielong.participants = [];
-                refreshActive(st);
-                gameStates.set(key, st);
+            setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
+            gameStates.set(key, st);
+            return;
+        }
+        if (cfg.enableCalc24 && st.calc24.started) {
+            clearGameTimer(st.calc24);
+            if (!st.calc24.players[playerKey]) {
+                st.calc24.players[playerKey] = getPlayerData(session);
+                st.calc24.participants.push(playerKey);
+            }
+            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]));
+                }
+                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();
+            }
+            st.calc24.playerAnswer = content;
+            const canCalculate = calculate24([...st.calc24.numbers]);
+            if (!canCalculate) {
+                await session.send(d.calc24.impossible);
+            }
+            else {
                 try {
-                    const intUserId = getIntUserId(s);
-                    const r = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
-                        params: {
-                            id: intUserId,
-                            msg: '开始成语接龙'
-                        },
-                        timeout: cfg.apiConfig.timeout,
-                        headers: {
-                            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-                        }
-                    });
-                    const dt = r.data;
-                    let m = d.chengyuJielong.start.replace('{0}', cfg.chengyuJielong.totalRounds.toString());
-                    if (dt.code === 200 && dt.data?.system) {
-                        const sys = dt.data.system;
-                        m += `\n我的第一个成语：${sys.idiom}（${sys.pinyin}）\n释义：${sys.meaning}`;
-                        st.chengyuJielong.lastChar = dt.data.current_char || '';
+                    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);
                     }
-                    await s.send(m);
                 }
-                catch (error) {
-                    await s.send(d.chengyuJielong.apiError);
+                catch {
+                    await session.send(d.calc24.wrong);
                 }
-                setupAutoStop(s, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
-                gameStates.set(key, st);
-                scheduleAutoPlay(s, key, st);
             }
-            else if (a === 'stop') {
-                st.chengyuJielong.started = false;
-                clearAllTimers(st);
-                await s.send(d.chengyuJielong.stop);
-                if (cfg.chengyuJielong.showRank && !isPrivate(s)) {
-                    const rankText = generateRankText(st.chengyuJielong.players);
-                    await s.send(rankText);
+            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.chengyuJielong);
-                gameStates.set(key, st);
+                clearGameData(st.calc24);
             }
             else {
-                await s.send(d.chengyuJielong.notStarted);
+                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('、')));
             }
-            return '';
-        });
-    }
-    if (cfg.enableNumberGuess) {
-        ctx.command('guess <action:string>')
-            .action(async (argv, action) => {
-            const s = argv.session;
-            if (!s)
-                return '';
-            const key = getSessionKey(s);
-            const st = gameStates.get(key) || initState(key, cfg);
-            if (action === 'start') {
-                if (checkGameRunning(st, 'guessNumber')) {
-                    s.send(d.common.gameRunning);
-                    return '';
-                }
-                st.guessNumber.started = true;
-                st.guessNumber.totalRounds = cfg.guessNumber.totalRounds;
-                st.guessNumber.currentRound = 1;
-                st.guessNumber.target = koishi_1.Random.int(st.guessNumber.currentMin, st.guessNumber.currentMax);
-                st.guessNumber.players = {};
-                st.guessNumber.participants = [];
-                gameStates.set(key, st);
-                await s.send(d.guessNumber.start.replace('{0}', cfg.guessNumber.totalRounds.toString()));
-                await s.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}，开始你的猜测吧！`);
-                setupAutoStop(s, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
-            }
-            else if (action === 'stop') {
-                st.guessNumber.started = false;
-                clearGameTimer(st.guessNumber);
-                await s.send(d.guessNumber.stop);
-                if (cfg.guessNumber.showRank && !isPrivate(s)) {
-                    const rankText = generateRankText(st.guessNumber.players);
-                    await s.send(rankText);
-                }
-                clearGameData(st.guessNumber);
-                gameStates.set(key, st);
+            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 (!/^\d{4}$/.test(content)) {
+                await session.send(d.passwordLock.invalidPassword);
+                setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+                return next();
+            }
+            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.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 {
-                await s.send(d.guessNumber.usage);
+                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);
+                        await session.send(rankText);
+                    }
+                    clearGameData(st.passwordLock);
+                }
+                else {
+                    await session.send(d.passwordLock.wrong.replace('{0}', hint));
+                    await session.send(`剩余猜测次数：${st.passwordLock.maxGuessTimes - st.passwordLock.guessTimes}`);
+                }
             }
-            return '';
-        });
-    }
+            setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+            gameStates.set(key, st);
+            return;
+        }
+        return next();
+    });
+    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)) {
+            await session.send(d.common.gameRunning);
+            return;
+        }
+        if (action === '开始') {
+            st.guessNumber.started = true;
+            st.guessNumber.target = koishi_1.Random.int(cfg.guessNumber.min, cfg.guessNumber.max);
+            st.guessNumber.currentMin = cfg.guessNumber.min;
+            st.guessNumber.currentMax = cfg.guessNumber.max;
+            st.guessNumber.currentRound = 1;
+            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);
+        }
+        else if (action === '结束') {
+            clearGameData(st.guessNumber);
+            await session.send(d.guessNumber.stop);
+            gameStates.set(key, st);
+        }
+        else {
+            await session.send(d.guessNumber.usage);
+        }
+    });
+    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)) {
+            await session.send(d.common.gameRunning);
+            return;
+        }
+        if (action === '开始') {
+            st.wzHero.started = true;
+            st.wzHero.difficulty = param || '简单';
+            st.wzHero.currentRound = 1;
+            try {
+                const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
+                    params: { id: getIntUserId(session), msg: `开始游戏${st.wzHero.difficulty}` },
+                    timeout: cfg.apiConfig.timeout
+                });
+                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(text);
+                st.wzHero.currentAnswer = dt.hint || '';
+            }
+            catch (e) {
+                await session.send(d.wzHero.apiError);
+            }
+            gameStates.set(key, st);
+            setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
+        }
+        else if (action === '结束') {
+            clearGameData(st.wzHero);
+            await session.send(d.wzHero.stop);
+            gameStates.set(key, st);
+        }
+        else {
+            await session.send(d.wzHero.startUsage);
+        }
+    });
+    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.chengyuImage.started = true;
+            st.chengyuImage.currentRound = 1;
+            try {
+                const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                    params: { action: 'next_question', page: 1 },
+                    timeout: cfg.apiConfig.timeout
+                });
+                const dt = r.data;
+                if (dt.success) {
+                    st.chengyuImage.currentId = dt.data.question.id;
+                    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(`请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
+                    await session.send(koishi_1.segment.image(dt.data.question.image_url));
+                }
+                else {
+                    await session.send(d.chengyuImage.apiError);
+                }
+            }
+            catch (e) {
+                await session.send(d.chengyuImage.apiError);
+            }
+            gameStates.set(key, st);
+            setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
+        }
+        else if (action === '结束') {
+            clearGameData(st.chengyuImage);
+            await session.send(d.chengyuImage.stop);
+            gameStates.set(key, st);
+        }
+        else {
+            await session.send(d.chengyuImage.submitUsage);
+        }
+    });
+    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.chengyuJielong.started = true;
+            st.chengyuJielong.currentRound = 1;
+            st.chengyuJielong.hasTriggeredAutoPlay = false;
+            st.chengyuJielong.autoPlayCount = 0;
+            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);
+        }
+        else if (action === '结束') {
+            clearGameData(st.chengyuJielong);
+            await session.send(d.chengyuJielong.stop);
+            gameStates.set(key, st);
+        }
+        else {
+            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;
+        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.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('、')));
+            gameStates.set(key, st);
+            setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+        }
+        else if (action === '结束') {
+            clearGameData(st.calc24);
+            await session.send(d.calc24.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.passwordLock.started = true;
+            st.passwordLock.currentRound = 1;
+            st.passwordLock.guessTimes = 0;
+            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);
+        }
+    });
 }