koishi-plugin-game-mini 0.1.5 → 0.1.7

package/lib/index.d.ts

@@ -3,11 +3,29 @@ export declare const name = "game-mini";
 export declare const using: readonly ["i18n"];
 export declare const inject: readonly ["console"];
 export interface Config {
+    enableNumberGuess: boolean;
+    enableWzHero: boolean;
+    enableChengyuImage: boolean;
+    enableChengyuJielong: boolean;
     guessNumber: {
         min: number;
         max: number;
         botParticipateInGroup: boolean;
     };
+    wzHero: {
+        botParticipateInGroup: boolean;
+    };
+    chengyuImage: {
+        botParticipateInGroup: boolean;
+    };
+    chengyuJielong: {
+        botParticipateInGroup: boolean;
+    };
+    apiConfig: {
+        wzHeroUserId: string;
+        cyjlUserId: string;
+        timeout: number;
+    };
 }
 export declare const Config: Schema<Config>;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -9,26 +9,79 @@ const koishi_1 = require("koishi");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
+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('是否开启猜数字游戏功能'),
+    enableWzHero: koishi_1.Schema.boolean().default(true).description('是否开启王者英雄猜谜游戏功能'),
+    enableChengyuImage: koishi_1.Schema.boolean().default(true).description('是否开启看图猜成语游戏功能'),
+    enableChengyuJielong: koishi_1.Schema.boolean().default(true).description('是否开启成语接龙游戏功能'),
     guessNumber: koishi_1.Schema.object({
         min: koishi_1.Schema.number().min(0).default(0).description('猜数字最小值（最低为0）'),
         max: koishi_1.Schema.number().min(1).default(100).description('猜数字最大值'),
-        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中Bot是否参与（私聊强制参与）')
-    }).description('猜数字游戏配置')
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中Bot是否参与猜数字（私聊强制参与）')
+    }).description('猜数字游戏配置'),
+    wzHero: koishi_1.Schema.object({
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中Bot是否参与王者英雄猜谜（私聊强制参与）')
+    }).description('王者英雄猜谜配置'),
+    chengyuImage: koishi_1.Schema.object({
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中Bot是否参与看图猜成语（私聊强制参与）')
+    }).description('看图猜成语配置'),
+    chengyuJielong: koishi_1.Schema.object({
+        botParticipateInGroup: koishi_1.Schema.boolean().default(true).description('群聊中Bot是否参与成语接龙（私聊强制参与）')
+    }).description('成语接龙配置'),
+    apiConfig: koishi_1.Schema.object({
+        wzHeroUserId: koishi_1.Schema.string().default('1828222534').description('王者英雄猜谜API的用户区分ID（建议填写Bot的QQ号/原生账号）'),
+        cyjlUserId: koishi_1.Schema.string().default('1828222534').description('成语接龙API的用户区分ID（建议填写Bot的QQ号/原生账号）'),
+        timeout: koishi_1.Schema.number().default(5000).description('第三方API请求超时时间（毫秒）')
+    }).description('游戏API配置')
 }).i18n({
     'zh-CN': {
+        'enableNumberGuess': '开启猜数字游戏',
+        'enableNumberGuess.description': '控制是否启用猜数字游戏功能',
+        'enableWzHero': '开启王者英雄猜谜',
+        'enableWzHero.description': '控制是否启用王者英雄猜谜游戏功能',
+        'enableChengyuImage': '开启看图猜成语',
+        'enableChengyuImage.description': '控制是否启用看图猜成语游戏功能',
+        'enableChengyuJielong': '开启成语接龙',
+        'enableChengyuJielong.description': '控制是否启用成语接龙游戏功能',
         'guessNumber.min': '猜数字最小值',
         'guessNumber.min.description': '设置猜数字游戏的最小值，最低限制为0',
         'guessNumber.max': '猜数字最大值',
         'guessNumber.max.description': '设置猜数字游戏的最大值，需大于0',
-        'guessNumber.botParticipateInGroup': '群聊Bot参与开关',
+        'guessNumber.botParticipateInGroup': '群聊Bot参与猜数字开关',
         'guessNumber.botParticipateInGroup.description': '控制Bot是否在群聊中参与猜数字，私聊场景下Bot强制参与',
-        'guessNumber': '猜数字游戏配置'
+        'guessNumber': '猜数字游戏配置',
+        'wzHero.botParticipateInGroup': '群聊Bot参与王者英雄猜谜开关',
+        'wzHero.botParticipateInGroup.description': '控制Bot是否在群聊中参与王者英雄猜谜，私聊场景下Bot强制参与',
+        'wzHero': '王者英雄猜谜配置',
+        'chengyuImage.botParticipateInGroup': '群聊Bot参与看图猜成语开关',
+        'chengyuImage.botParticipateInGroup.description': '控制Bot是否在群聊中参与看图猜成语，私聊场景下Bot强制参与',
+        'chengyuImage': '看图猜成语配置',
+        'chengyuJielong.botParticipateInGroup': '群聊Bot参与成语接龙开关',
+        'chengyuJielong.botParticipateInGroup.description': '控制Bot是否在群聊中参与成语接龙，私聊场景下Bot强制参与',
+        'chengyuJielong': '成语接龙配置',
+        'apiConfig.wzHeroUserId': '王者英雄猜谜API用户ID',
+        'apiConfig.wzHeroUserId.description': '用于区分Bot参与的ID，建议填写Bot的QQ号/原生账号',
+        'apiConfig.cyjlUserId': '成语接龙API用户ID',
+        'apiConfig.cyjlUserId.description': '用于区分Bot参与的ID，建议填写Bot的QQ号/原生账号',
+        'apiConfig.timeout': 'API超时时间',
+        'apiConfig.timeout.description': '第三方API请求的超时时间，单位为毫秒',
+        'apiConfig': '游戏API配置'
     }
 });
+const logger = new koishi_1.Logger('game-mini');
+const commandDescriptions = {
+    guessNumber: '猜数字小游戏指令',
+    wzHero: '猜王者荣耀英雄小游戏指令',
+    chengyuImage: '看图猜成语小游戏指令',
+    chengyuJielong: '成语接龙小游戏指令'
+};
+const getUserRealId = (session) => {
+    return session.userId || `${session.platform}_${session.selfId}`;
+};
 function apply(ctx, config) {
     const defaultI18n = {
         guessNumber: {
@@ -42,7 +95,41 @@ function apply(ctx, config) {
             botWin: '哈哈我猜中了！我猜的是 {0}，正确数字就是 {0}，我赢啦 🎉',
             botGuessTooSmall: '我猜 {0}，猜小啦！当前范围 [{1}-{2}]',
             botGuessTooBig: '我猜 {0}，猜大啦！当前范围 [{1}-{2}]',
-            commandDesc: '猜数字小游戏指令'
+            disabled: '猜数字游戏功能已关闭，请联系管理员开启',
+        },
+        wzHero: {
+            startUsage: '用法错误！正确用法：wzhero start [难度]，难度可选：简单/中等/困难',
+            stop: '王者英雄猜谜游戏已停止',
+            notStarted: '王者英雄猜谜游戏尚未开始，请输入 wzhero start [难度] 开始游戏',
+            hint: '提示',
+            apiError: 'API请求失败，请稍后再试',
+            botGuess: '让我猜猜～我觉得是：{0}',
+            botWrong: '哎呀猜错了😜，继续猜猜看！',
+            botRight: '耶！我猜对了～就是{0} ✨',
+            disabled: '王者英雄猜谜功能已关闭，请联系管理员开启',
+        },
+        chengyuImage: {
+            start: '看图猜成语游戏开始！',
+            stop: '看图猜成语游戏已停止',
+            submitUsage: '请直接输入你猜测的成语，或输入 提示 获取线索',
+            notStarted: '看图猜成语游戏尚未开始，请输入 cyimage start 开始游戏',
+            next: '下一题来啦！',
+            hintUsage: '提示等级可选1-5，用法：提示 <等级>，如 提示 2',
+            apiError: 'API请求失败，请稍后再试',
+            botGuess: '我来试试！我猜是：{0}',
+            botWrong: '猜错了😭，换个试试！',
+            botRight: '太棒了！我猜对了～就是{0} 🎊',
+            disabled: '看图猜成语功能已关闭，请联系管理员开启',
+        },
+        chengyuJielong: {
+            start: '成语接龙游戏开始！我先来～',
+            stop: '成语接龙游戏已停止',
+            notStarted: '成语接龙游戏尚未开始，请输入 cyjl start 开始游戏',
+            joinUsage: '请输入 我接<成语> 进行接龙，如 我接一帆风顺',
+            apiError: 'API请求失败，请稍后再试',
+            botTurn: '该我了！我接：{0}（{1}）\n释义：{2}',
+            botWin: '哈哈我接不上了，你赢啦～',
+            disabled: '成语接龙功能已关闭，请联系管理员开启',
         }
     };
     try {
@@ -56,103 +143,607 @@ function apply(ctx, config) {
         }
     }
     catch (e) {
+        logger.warn('加载i18n配置失败，使用默认配置:', e);
         ctx.i18n.define('zh-CN', defaultI18n);
     }
-    const guessNumberStates = new Map();
+    const gameStates = new Map();
     const getSessionKey = (session) => session.channelId ? `group:${session.channelId}` : `private:${session.userId}`;
+    const getBotParticipate = (session, gameType) => {
+        const isPrivate = !session.channelId;
+        if (isPrivate)
+            return true;
+        switch (gameType) {
+            case 'guessNumber':
+                return config.guessNumber.botParticipateInGroup;
+            case 'wzHero':
+                return config.wzHero.botParticipateInGroup;
+            case 'chengyuImage':
+                return config.chengyuImage.botParticipateInGroup;
+            case 'chengyuJielong':
+                return config.chengyuJielong.botParticipateInGroup;
+            default:
+                return true;
+        }
+    };
+    const initSessionState = (key) => {
+        const state = {
+            guessNumber: {
+                target: 0,
+                currentMin: config.guessNumber.min,
+                currentMax: config.guessNumber.max,
+                started: false,
+                botGuess: []
+            },
+            wzHero: {
+                started: false,
+                difficulty: '',
+                botAnswered: false,
+                lastHint: ''
+            },
+            chengyuImage: {
+                started: false,
+                currentId: '',
+                currentPage: 1,
+                botGuessed: false,
+                options: []
+            },
+            chengyuJielong: {
+                started: false,
+                lastChar: '',
+                botTurn: true
+            }
+        };
+        gameStates.set(key, state);
+        return state;
+    };
     ctx.middleware(async (session, next) => {
         if (!session.content)
             return next();
         const key = getSessionKey(session);
-        const state = guessNumberStates.get(key);
-        if (!state || !state.started)
-            return next();
-        const num = parseInt(session.content.trim());
-        if (isNaN(num) || !Number.isInteger(num))
-            return next();
-        let reply = '';
-        if (num < state.currentMin || num > state.currentMax) {
-            reply = session.text('guessNumber.outOfRange', [state.currentMin, state.currentMax]);
-        }
-        else if (num < state.target) {
-            state.currentMin = num + 1;
-            reply = session.text('guessNumber.tooSmall', [state.currentMin, state.currentMax]);
+        const state = gameStates.get(key) || initSessionState(key);
+        if (config.enableNumberGuess && state.guessNumber.started) {
+            const num = parseInt(session.content.trim());
+            if (!isNaN(num) && Number.isInteger(num)) {
+                let reply = '';
+                const gnState = state.guessNumber;
+                if (num < gnState.currentMin || num > gnState.currentMax) {
+                    reply = session.text('guessNumber.outOfRange', [gnState.currentMin, gnState.currentMax]);
+                }
+                else if (num < gnState.target) {
+                    gnState.currentMin = num + 1;
+                    reply = session.text('guessNumber.tooSmall', [gnState.currentMin, gnState.currentMax]);
+                }
+                else if (num > gnState.target) {
+                    gnState.currentMax = num - 1;
+                    reply = session.text('guessNumber.tooBig', [gnState.currentMin, gnState.currentMax]);
+                }
+                else {
+                    gnState.started = false;
+                    gameStates.set(key, state);
+                    reply = session.text('guessNumber.correct', [gnState.target]);
+                    await session.send(reply);
+                    return;
+                }
+                gameStates.set(key, state);
+                const botPlay = getBotParticipate(session, 'guessNumber');
+                if (botPlay && gnState.started && gnState.currentMin <= gnState.currentMax) {
+                    let botGuess;
+                    let safe = 0;
+                    do {
+                        botGuess = koishi_1.Random.int(gnState.currentMin, gnState.currentMax);
+                        safe++;
+                    } while ((botGuess === gnState.target || gnState.botGuess.includes(botGuess)) && safe < 20);
+                    gnState.botGuess.push(botGuess);
+                    if (botGuess === gnState.target) {
+                        reply += session.text('guessNumber.botWin', [botGuess]);
+                        gnState.started = false;
+                    }
+                    else if (botGuess < gnState.target) {
+                        gnState.currentMin = botGuess + 1;
+                        reply += session.text('guessNumber.botGuessTooSmall', [botGuess, gnState.currentMin, gnState.currentMax]);
+                    }
+                    else {
+                        gnState.currentMax = botGuess - 1;
+                        reply += session.text('guessNumber.botGuessTooBig', [botGuess, gnState.currentMin, gnState.currentMax]);
+                    }
+                    gameStates.set(key, state);
+                }
+                await session.send(reply);
+                return;
+            }
         }
-        else if (num > state.target) {
-            state.currentMax = num - 1;
-            reply = session.text('guessNumber.tooBig', [state.currentMin, state.currentMax]);
+        if (config.enableWzHero && state.wzHero.started) {
+            const content = session.content.trim();
+            const wzState = state.wzHero;
+            try {
+                const response = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
+                    params: {
+                        id: getUserRealId(session),
+                        msg: content
+                    },
+                    timeout: config.apiConfig.timeout
+                });
+                const data = response.data;
+                let reply = '';
+                if (data.status === 'success') {
+                    if (data.message.includes('用完了所有提示') || data.remaining_hints === 0) {
+                        reply = '很遗憾，你用完了所有提示！难度太大？可以向我发送“wzhero start 简单”以降低猜测英雄难度。游戏开始！当前难度：简单\n请看题，下面是一首描写该英雄的诗词。\n胡笳琴韵愈伤痕\n弹弹连控摄敌魂\n加血提速护友紧\n奶妈之名天下闻\n请输入你猜测的英雄名称，或输入"提示"获取下一条线索';
+                    }
+                    else {
+                        reply = `${data.message || ''}\n${data.hint || ''}\n剩余提示次数：${data.remaining_hints}\n${data.guide || ''}`;
+                        wzState.lastHint = data.hint || '';
+                    }
+                }
+                else {
+                    reply = data.message || '游戏出错了，请稍后再试';
+                }
+                await session.send(reply);
+                const botPlay = getBotParticipate(session, 'wzHero');
+                if (botPlay && !wzState.botAnswered) {
+                    setTimeout(async () => {
+                        const heroList = ['李白', '韩信', '貂蝉', '诸葛亮', '妲己', '亚瑟', '鲁班七号', '孙尚香', '孙悟空', '安琪拉'];
+                        const randomHero = heroList[Math.floor(Math.random() * heroList.length)];
+                        const botResponse = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
+                            params: {
+                                id: config.apiConfig.wzHeroUserId,
+                                msg: randomHero
+                            },
+                            timeout: config.apiConfig.timeout
+                        });
+                        let botReply = session.text('wzHero.botGuess', [randomHero]);
+                        if (botResponse.data.status !== 'success' || botResponse.data.message.includes('错误') || botResponse.data.message.includes('不对')) {
+                            botReply += '\n' + session.text('wzHero.botWrong');
+                        }
+                        else {
+                            botReply += '\n' + session.text('wzHero.botRight', [randomHero]);
+                            wzState.started = false;
+                        }
+                        wzState.botAnswered = true;
+                        gameStates.set(key, state);
+                        await session.send(botReply);
+                    }, 3000);
+                }
+            }
+            catch (error) {
+                logger.error('王者英雄猜谜API请求失败:', error);
+                await session.send(session.text('wzHero.apiError'));
+            }
+            return;
         }
-        else {
-            state.started = false;
-            guessNumberStates.set(key, state);
-            reply = session.text('guessNumber.correct', [state.target]);
-            await session.send(reply);
+        if (config.enableChengyuImage && state.chengyuImage.started) {
+            const content = session.content.trim();
+            const cyImageState = state.chengyuImage;
+            const currentId = cyImageState.currentId;
+            try {
+                let reply = '';
+                if (content.startsWith('提示')) {
+                    const level = content.split(' ')[1] || '1';
+                    const levelNum = parseInt(level);
+                    const validLevel = isNaN(levelNum) || levelNum < 1 || levelNum > 5 ? 1 : levelNum;
+                    const response = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                        params: {
+                            action: 'get_hint',
+                            id: currentId,
+                            level: validLevel
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    reply = data.success ? data.message : '获取提示失败，请稍后再试';
+                }
+                else if (content === '下一题') {
+                    const response = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                        params: {
+                            action: 'next_question',
+                            page: cyImageState.currentPage + 1
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    if (data.success) {
+                        cyImageState.currentId = data.data.question.id;
+                        cyImageState.currentPage = data.data.question.page;
+                        cyImageState.options = data.data.question.options;
+                        cyImageState.botGuessed = false;
+                        gameStates.set(key, state);
+                        reply = `${session.text('chengyuImage.next')}\n${data.data.message}\n选项：${data.data.question.options.join('、')}\n[CQ:image,file=${data.data.question.image_url}]`;
+                    }
+                    else {
+                        reply = '获取下一题失败，请稍后再试';
+                    }
+                }
+                else {
+                    const response = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                        params: {
+                            action: 'submit_answer',
+                            id: currentId,
+                            answer: content
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    if (data.success) {
+                        reply = data.message;
+                        if (data.message.includes('正确') || data.message.includes('答对')) {
+                            state.chengyuImage.started = false;
+                        }
+                    }
+                    else {
+                        reply = '提交答案失败，请稍后再试';
+                    }
+                }
+                await session.send(reply);
+                const botPlay = getBotParticipate(session, 'chengyuImage');
+                if (botPlay && !cyImageState.botGuessed && cyImageState.options.length > 0) {
+                    setTimeout(async () => {
+                        const randomWords = [];
+                        for (let i = 0; i < 4; i++) {
+                            if (cyImageState.options.length > i) {
+                                randomWords.push(cyImageState.options[Math.floor(Math.random() * cyImageState.options.length)]);
+                            }
+                        }
+                        const randomIdiom = randomWords.join('');
+                        const botResponse = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                            params: {
+                                action: 'submit_answer',
+                                id: currentId,
+                                answer: randomIdiom
+                            },
+                            timeout: config.apiConfig.timeout
+                        });
+                        let botReply = session.text('chengyuImage.botGuess', [randomIdiom]);
+                        if (botResponse.data.message.includes('错误') || botResponse.data.message.includes('不对')) {
+                            botReply += '\n' + session.text('chengyuImage.botWrong');
+                        }
+                        else {
+                            botReply += '\n' + session.text('chengyuImage.botRight', [randomIdiom]);
+                            cyImageState.started = false;
+                        }
+                        cyImageState.botGuessed = true;
+                        gameStates.set(key, state);
+                        await session.send(botReply);
+                    }, 3000);
+                }
+            }
+            catch (error) {
+                logger.error('看图猜成语API请求失败:', error);
+                await session.send(session.text('chengyuImage.apiError'));
+            }
             return;
         }
-        guessNumberStates.set(key, state);
-        const isPrivate = !session.channelId;
-        const botPlay = isPrivate || config.guessNumber.botParticipateInGroup;
-        if (botPlay && state.started && state.currentMin <= state.currentMax) {
-            let botGuess;
-            let safe = 0;
-            do {
-                botGuess = koishi_1.Random.int(state.currentMin, state.currentMax);
-                safe++;
-            } while ((botGuess === state.target || state.botGuess.includes(botGuess)) && safe < 20);
-            state.botGuess.push(botGuess);
-            guessNumberStates.set(key, state);
-            if (botGuess === state.target) {
-                reply += session.text('guessNumber.botWin', [botGuess]);
-                state.started = false;
-                guessNumberStates.set(key, state);
-            }
-            else if (botGuess < state.target) {
-                state.currentMin = botGuess + 1;
-                guessNumberStates.set(key, state);
-                reply += session.text('guessNumber.botGuessTooSmall', [botGuess, state.currentMin, state.currentMax]);
+        if (config.enableChengyuJielong && state.chengyuJielong.started) {
+            const content = session.content.trim();
+            const cyJlState = state.chengyuJielong;
+            if (!content.startsWith('我接')) {
+                await session.send(session.text('chengyuJielong.joinUsage'));
+                return;
             }
-            else {
-                state.currentMax = botGuess - 1;
-                guessNumberStates.set(key, state);
-                reply += session.text('guessNumber.botGuessTooBig', [botGuess, state.currentMin, state.currentMax]);
+            const idiom = content.substring(2).trim();
+            if (!idiom) {
+                await session.send(session.text('chengyuJielong.joinUsage'));
+                return;
+            }
+            try {
+                const response = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
+                    params: {
+                        id: getUserRealId(session),
+                        msg: `我接${idiom}`
+                    },
+                    timeout: config.apiConfig.timeout
+                });
+                const data = response.data;
+                let reply = '';
+                if (data.code === 200) {
+                    reply = `${data.msg}\n`;
+                    if (data.data.user) {
+                        reply += `你的成语：${data.data.user.idiom}（${data.data.user.pinyin}）\n释义：${data.data.user.meaning}\n`;
+                        cyJlState.lastChar = data.data.current_char || '';
+                    }
+                    if (data.data.system) {
+                        reply += `我的接龙：${data.data.system.idiom}（${data.data.system.pinyin}）\n释义：${data.data.system.meaning}\n当前接字：${data.data.current_char}`;
+                        cyJlState.lastChar = data.data.current_char || '';
+                    }
+                }
+                else {
+                    reply = data.msg || '接龙失败，请换个成语试试';
+                }
+                await session.send(reply);
+                const botPlay = getBotParticipate(session, 'chengyuJielong');
+                if (botPlay && cyJlState.lastChar) {
+                    setTimeout(async () => {
+                        const botResponse = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
+                            params: {
+                                id: config.apiConfig.cyjlUserId,
+                                msg: `开始成语接龙`
+                            },
+                            timeout: config.apiConfig.timeout
+                        });
+                        if (botResponse.data.code === 200 && botResponse.data.data.system) {
+                            const botIdiom = botResponse.data.data.system.idiom;
+                            const botPinyin = botResponse.data.data.system.pinyin;
+                            const botMeaning = botResponse.data.data.system.meaning;
+                            const botChar = botResponse.data.data.current_char;
+                            const botReply = session.text('chengyuJielong.botTurn', [botIdiom, botPinyin, botMeaning]);
+                            cyJlState.lastChar = botChar;
+                            gameStates.set(key, state);
+                            await session.send(botReply);
+                        }
+                    }, 2000);
+                }
             }
+            catch (error) {
+                logger.error('成语接龙API请求失败:', error);
+                await session.send(session.text('chengyuJielong.apiError'));
+            }
+            return;
         }
-        await session.send(reply);
+        return next();
     });
-    ctx.command('guess <action:string>', '猜数字小游戏指令')
-        .action(async ({ session }, action) => {
-        if (!session)
+    if (config.enableNumberGuess) {
+        ctx.command('guess <action:string>', commandDescriptions.guessNumber)
+            .action(async (argv, action) => {
+            const session = argv.session;
+            if (!session || !action) {
+                await session?.send(session.text('guessNumber.usage'));
+                return '';
+            }
+            const key = getSessionKey(session);
+            const state = gameStates.get(key) || initSessionState(key);
+            if (action === 'start') {
+                state.guessNumber.target = koishi_1.Random.int(config.guessNumber.min, config.guessNumber.max);
+                state.guessNumber.currentMin = config.guessNumber.min;
+                state.guessNumber.currentMax = config.guessNumber.max;
+                state.guessNumber.started = true;
+                state.guessNumber.botGuess = [];
+                gameStates.set(key, state);
+                await session.send(session.text('guessNumber.start', [config.guessNumber.min, config.guessNumber.max]));
+                const botPlay = getBotParticipate(session, 'guessNumber');
+                if (botPlay) {
+                    setTimeout(async () => {
+                        const botGuess = koishi_1.Random.int(config.guessNumber.min, config.guessNumber.max);
+                        state.guessNumber.botGuess.push(botGuess);
+                        gameStates.set(key, state);
+                        let botReply = '';
+                        if (botGuess < state.guessNumber.target) {
+                            state.guessNumber.currentMin = botGuess + 1;
+                            botReply = session.text('guessNumber.botGuessTooSmall', [botGuess, state.guessNumber.currentMin, state.guessNumber.currentMax]);
+                        }
+                        else if (botGuess > state.guessNumber.target) {
+                            state.guessNumber.currentMax = botGuess - 1;
+                            botReply = session.text('guessNumber.botGuessTooBig', [botGuess, state.guessNumber.currentMin, state.guessNumber.currentMax]);
+                        }
+                        else {
+                            botReply = session.text('guessNumber.botWin', [botGuess]);
+                            state.guessNumber.started = false;
+                        }
+                        gameStates.set(key, state);
+                        await session.send(botReply);
+                    }, 1000);
+                }
+            }
+            else if (action === 'stop') {
+                state.guessNumber.started = false;
+                gameStates.set(key, state);
+                await session.send(session.text('guessNumber.stop', [state.guessNumber.target]));
+            }
+            else {
+                await session.send(session.text('guessNumber.usage'));
+            }
             return '';
-        const key = getSessionKey(session);
-        let state = guessNumberStates.get(key) || {
-            target: 0,
-            currentMin: config.guessNumber.min,
-            currentMax: config.guessNumber.max,
-            started: false,
-            botGuess: []
-        };
-        if (!action) {
-            await session.send(session.text('guessNumber.usage'));
+        });
+    }
+    if (config.enableWzHero) {
+        ctx.command('wzhero <action:string> [difficulty:string]', commandDescriptions.wzHero)
+            .usage('用法：wzhero start [难度]，难度可选：简单/中等/困难，默认中等')
+            .action(async (argv, action, difficulty) => {
+            const session = argv.session;
+            if (!session || !action) {
+                await session?.send('用法错误！正确用法：wzhero start [难度]，难度可选：简单/中等/困难');
+                return '';
+            }
+            const key = getSessionKey(session);
+            const state = gameStates.get(key) || initSessionState(key);
+            if (action === 'start') {
+                const finalDifficulty = difficulty || '中等';
+                if (!['简单', '中等', '困难'].includes(finalDifficulty)) {
+                    await session.send('用法错误！正确用法：wzhero start [难度]，难度可选：简单/中等/困难');
+                    return '';
+                }
+                state.wzHero.started = true;
+                state.wzHero.difficulty = finalDifficulty;
+                state.wzHero.botAnswered = false;
+                gameStates.set(key, state);
+                try {
+                    const response = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
+                        params: {
+                            id: getUserRealId(session),
+                            msg: `开始游戏${finalDifficulty}`
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    let reply = '';
+                    if (data.status === 'success') {
+                        reply = `${data.message || ''}\n${data.hint || ''}\n${data.guide || ''}`;
+                        state.wzHero.lastHint = data.hint || '';
+                    }
+                    else {
+                        reply = data.message || '游戏开始失败，请稍后再试';
+                    }
+                    await session.send(reply);
+                    const botPlay = getBotParticipate(session, 'wzHero');
+                    if (botPlay) {
+                        setTimeout(async () => {
+                            const heroList = ['李白', '韩信', '貂蝉', '诸葛亮', '妲己', '亚瑟', '鲁班七号', '孙尚香', '孙悟空', '安琪拉'];
+                            const randomHero = heroList[Math.floor(Math.random() * heroList.length)];
+                            const botResponse = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
+                                params: {
+                                    id: config.apiConfig.wzHeroUserId,
+                                    msg: randomHero
+                                },
+                                timeout: config.apiConfig.timeout
+                            });
+                            let botReply = session.text('wzHero.botGuess', [randomHero]);
+                            if (botResponse.data.status !== 'success' || botResponse.data.message.includes('错误') || botResponse.data.message.includes('不对')) {
+                                botReply += '\n' + session.text('wzHero.botWrong');
+                            }
+                            else {
+                                botReply += '\n' + session.text('wzHero.botRight', [randomHero]);
+                                state.wzHero.started = false;
+                            }
+                            state.wzHero.botAnswered = true;
+                            gameStates.set(key, state);
+                            await session.send(botReply);
+                        }, 2000);
+                    }
+                }
+                catch (error) {
+                    logger.error('王者英雄猜谜开始游戏失败:', error);
+                    await session.send(session.text('wzHero.apiError'));
+                    state.wzHero.started = false;
+                    gameStates.set(key, state);
+                }
+            }
+            else if (action === 'stop') {
+                state.wzHero.started = false;
+                gameStates.set(key, state);
+                await session.send(session.text('wzHero.stop'));
+            }
+            else {
+                await session.send('用法错误！正确用法：wzhero start [难度]，难度可选：简单/中等/困难');
+            }
             return '';
-        }
-        if (action === 'start') {
-            state.target = koishi_1.Random.int(config.guessNumber.min, config.guessNumber.max);
-            state.currentMin = config.guessNumber.min;
-            state.currentMax = config.guessNumber.max;
-            state.started = true;
-            state.botGuess = [];
-            guessNumberStates.set(key, state);
-            const msg = session.text('guessNumber.start', [config.guessNumber.min, config.guessNumber.max]);
-            await session.send(msg);
+        });
+    }
+    if (config.enableChengyuImage) {
+        ctx.command('cyimage <action:string>', commandDescriptions.chengyuImage)
+            .action(async (argv, action) => {
+            const session = argv.session;
+            if (!session || !action) {
+                await session?.send(session.text('chengyuImage.submitUsage'));
+                return '';
+            }
+            const key = getSessionKey(session);
+            const state = gameStates.get(key) || initSessionState(key);
+            if (action === 'start') {
+                try {
+                    const response = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                        params: {
+                            action: 'get_question'
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    if (data.success) {
+                        state.chengyuImage.started = true;
+                        state.chengyuImage.currentId = data.data.question.id;
+                        state.chengyuImage.currentPage = data.data.question.page;
+                        state.chengyuImage.options = data.data.question.options;
+                        state.chengyuImage.botGuessed = false;
+                        gameStates.set(key, state);
+                        const reply = `${session.text('chengyuImage.start')}\n${data.data.message}\n选项：${data.data.question.options.join('、')}\n[CQ:image,file=${data.data.question.image_url}]`;
+                        await session.send(reply);
+                        const botPlay = getBotParticipate(session, 'chengyuImage');
+                        if (botPlay) {
+                            setTimeout(async () => {
+                                const randomWords = [];
+                                for (let i = 0; i < 4; i++) {
+                                    if (data.data.question.options.length > i) {
+                                        randomWords.push(data.data.question.options[Math.floor(Math.random() * data.data.question.options.length)]);
+                                    }
+                                }
+                                const randomIdiom = randomWords.join('');
+                                const botResponse = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
+                                    params: {
+                                        action: 'submit_answer',
+                                        id: data.data.question.id,
+                                        answer: randomIdiom
+                                    },
+                                    timeout: config.apiConfig.timeout
+                                });
+                                let botReply = session.text('chengyuImage.botGuess', [randomIdiom]);
+                                if (botResponse.data.message.includes('错误') || botResponse.data.message.includes('不对')) {
+                                    botReply += '\n' + session.text('chengyuImage.botWrong');
+                                }
+                                else {
+                                    botReply += '\n' + session.text('chengyuImage.botRight', [randomIdiom]);
+                                    state.chengyuImage.started = false;
+                                }
+                                state.chengyuImage.botGuessed = true;
+                                gameStates.set(key, state);
+                                await session.send(botReply);
+                            }, 2000);
+                        }
+                    }
+                    else {
+                        await session.send('获取题目失败，请稍后再试');
+                    }
+                }
+                catch (error) {
+                    logger.error('看图猜成语开始游戏失败:', error);
+                    await session.send(session.text('chengyuImage.apiError'));
+                }
+            }
+            else if (action === 'stop') {
+                state.chengyuImage.started = false;
+                gameStates.set(key, state);
+                await session.send(session.text('chengyuImage.stop'));
+            }
+            else {
+                await session.send(session.text('chengyuImage.submitUsage'));
+            }
             return '';
-        }
-        if (action === 'stop') {
-            state.started = false;
-            guessNumberStates.set(key, state);
-            await session.send(session.text('guessNumber.stop', [state.target]));
+        });
+    }
+    if (config.enableChengyuJielong) {
+        ctx.command('cyjl <action:string>', commandDescriptions.chengyuJielong)
+            .action(async (argv, action) => {
+            const session = argv.session;
+            if (!session || !action) {
+                await session?.send(session.text('chengyuJielong.joinUsage'));
+                return '';
+            }
+            const key = getSessionKey(session);
+            const state = gameStates.get(key) || initSessionState(key);
+            if (action === 'start') {
+                state.chengyuJielong.started = true;
+                state.chengyuJielong.botTurn = true;
+                gameStates.set(key, state);
+                try {
+                    const response = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
+                        params: {
+                            id: getUserRealId(session),
+                            msg: '开始成语接龙'
+                        },
+                        timeout: config.apiConfig.timeout
+                    });
+                    const data = response.data;
+                    let reply = session.text('chengyuJielong.start');
+                    if (data.code === 200) {
+                        reply += `\n我的第一个成语：${data.data.system.idiom}（${data.data.system.pinyin}）\n释义：${data.data.system.meaning}\n当前接字：${data.data.current_char}`;
+                        state.chengyuJielong.lastChar = data.data.current_char || '';
+                    }
+                    else {
+                        reply = data.msg || '游戏开始失败，请稍后再试';
+                    }
+                    await session.send(reply);
+                }
+                catch (error) {
+                    logger.error('成语接龙开始游戏失败:', error);
+                    await session.send(session.text('chengyuJielong.apiError'));
+                    state.chengyuJielong.started = false;
+                    gameStates.set(key, state);
+                }
+            }
+            else if (action === 'stop') {
+                state.chengyuJielong.started = false;
+                gameStates.set(key, state);
+                await session.send(session.text('chengyuJielong.stop'));
+            }
+            else {
+                await session.send(session.text('chengyuJielong.joinUsage'));
+            }
             return '';
-        }
-        await session.send(session.text('guessNumber.usage'));
-        return '';
-    });
+        });
+    }
 }

package/lib/locales/locales/zh-CN.yml

@@ -1,12 +1,47 @@
+# locales/zh-CN.yml
 guessNumber:
-  usage: 用法错误！正确用法：guess start/stop 或 直接输入数字
-  start: 猜数字游戏开始！初始范围是 {0}-{1}，快来猜猜看～
-  stop: 猜数字游戏已停止，正确数字是 {0}
-  outOfRange: 数字超出当前范围 [{0}-{1}]，请重新输入！
-  tooSmall: 猜小啦！当前范围更新为 [{0}-{1}]
-  tooBig: 猜大啦！当前范围更新为 [{0}-{1}]
-  correct: 恭喜你猜中了！正确数字就是 {0} 🎉
-  botWin: 哈哈我猜中了！我猜的是 {0}，正确数字就是 {0}，我赢啦 🎉
-  botGuessTooSmall: 我猜 {0}，猜小啦！当前范围 [{1}-{2}]
-  botGuessTooBig: 我猜 {0}，猜大啦！当前范围 [{1}-{2}]
-  commandDesc: 猜数字小游戏指令
+  usage: "用法错误！正确用法：guess start/stop 或 直接输入数字"
+  start: "猜数字游戏开始！初始范围是 {0}-{1}，快来猜猜看～"
+  stop: "猜数字游戏已停止，正确数字是 {0}"
+  outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！"
+  tooSmall: "猜小啦！当前范围更新为 [{0}-{1}]"
+  tooBig: "猜大啦！当前范围更新为 [{0}-{1}]"
+  correct: "恭喜你猜中了！正确数字就是 {0} 🎉"
+  botWin: "哈哈我猜中了！我猜的是 {0}，正确数字就是 {0}，我赢啦 🎉"
+  botGuessTooSmall: "我猜 {0}，猜小啦！当前范围 [{1}-{2}]"
+  botGuessTooBig: "我猜 {0}，猜大啦！当前范围 [{1}-{2}]"
+  disabled: "猜数字游戏功能已关闭，请联系管理员开启"
+
+wzHero:
+  startUsage: "用法错误！正确用法：wzhero start [难度]，难度可选：简单/中等/困难"
+  stop: "王者英雄猜谜游戏已停止"
+  notStarted: "王者英雄猜谜游戏尚未开始，请输入 wzhero start [难度] 开始游戏"
+  hint: "提示"
+  apiError: "API请求失败，请稍后再试"
+  botGuess: "让我猜猜～我觉得是：{0}"
+  botWrong: "哎呀猜错了😜，继续猜猜看！"
+  botRight: "耶！我猜对了～就是{0} ✨"
+  disabled: "王者英雄猜谜功能已关闭，请联系管理员开启"
+
+chengyuImage:
+  start: "看图猜成语游戏开始！"
+  stop: "看图猜成语游戏已停止"
+  submitUsage: "请直接输入你猜测的成语，或输入 提示 获取线索"
+  notStarted: "看图猜成语游戏尚未开始，请输入 cyimage start 开始游戏"
+  next: "下一题来啦！"
+  hintUsage: "提示等级可选1-5，用法：提示 <等级>，如 提示 2"
+  apiError: "API请求失败，请稍后再试"
+  botGuess: "我来试试！我猜是：{0}"
+  botWrong: "猜错了😭，换个试试！"
+  botRight: "太棒了！我猜对了～就是{0} 🎊"
+  disabled: "看图猜成语功能已关闭，请联系管理员开启"
+
+chengyuJielong:
+  start: "成语接龙游戏开始！我先来～"
+  stop: "成语接龙游戏已停止"
+  notStarted: "成语接龙游戏尚未开始，请输入 cyjl start 开始游戏"
+  joinUsage: "请输入 我接<成语> 进行接龙，如 我接一帆风顺"
+  apiError: "API请求失败，请稍后再试"
+  botTurn: "该我了！我接：{0}（{1}）\n释义：{2}"
+  botWin: "哈哈我接不上了，你赢啦～"
+  disabled: "成语接龙功能已关闭，请联系管理员开启"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-game-mini",
-  "version": "0.1.5",
-  "description": "一款简单的猜数字小游戏，支持Bot参与",
+  "version": "0.1.7",
+  "description": "一款包含猜数字、猜王者英雄、看图猜成语、成语接龙的多功能小游戏插件",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -14,7 +14,10 @@
     "koishi",
     "plugin",
     "game",
-    "猜数字"
+    "猜数字",
+    "王者荣耀",
+    "猜成语",
+    "成语接龙"
   ],
   "author": "Minecraft-1314",
   "license": "MIT",
@@ -28,10 +31,13 @@
   "homepage": "https://github.com/Minecraft-1314/koishi-plugin-game-mini#readme",
   "peerDependencies": {
     "koishi": "^4.0.0",
-    "yaml": "^2.0.0"
+    "yaml": "^2.0.0",
+    "axios": "^1.0.0"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
-    "copyfiles": "^2.4.1"
+    "copyfiles": "^2.4.1",
+    "@types/node": "^20.0.0",
+    "@types/fs-extra": "^11.0.0"
   }
 }

package/readme.md

@@ -1,48 +1,119 @@
 # koishi-plugin-game-mini
 
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Koishi Version](https://img.shields.io/badge/Koishi-%3E%3D4.0.0-brightgreen.svg)](https://koishi.chat/)
+
 ## 项目介绍 (Project Introduction)
 
 ### 中文
-这是一款为 Koishi 聊天机器人框架开发的轻量级猜数字小游戏插件，核心玩法贴合经典“终极密码”规则，兼具易用性与可配置性：
-- 支持自定义猜数字的数值范围（默认 0-100）
-- 区分群聊/私聊模式：私聊时 Bot 强制参与，群聊可通过配置开关控制 Bot 是否参与
+这是一款为 Koishi 聊天机器人框架开发的轻量级多功能小游戏插件，包含经典猜数字、猜王者荣耀英雄、看图猜成语、成语接龙四款趣味游戏，兼具易用性与可配置性：
+- **猜数字**：支持自定义数值范围（默认 0-100），区分群聊/私聊模式控制 Bot 参与状态
+- **猜王者英雄**：基于诗词/提示猜王者荣耀英雄，支持简单/中等/困难三种难度
+- **看图猜成语**：根据图片和备选字猜成语，支持提示功能和切换题目
+- **成语接龙**：与 Bot 进行成语接龙对战，自动返回成语拼音和释义
 
 ### English
-This is a lightweight number guessing game plugin developed for the Koishi chatbot framework, with core gameplay adhering to the classic "Ultimate Password" rules and both ease of use and configurability:
-- Supports customizable number range for guessing (default 0-100)
-- Differentiates between group chat and private chat modes: Bots are forced to participate in private chats, while bot participation in group chats can be controlled via configuration switch
+This is a lightweight multi-functional game plugin developed for the Koishi chatbot framework, including four fun games: classic number guessing, King of Glory hero guessing, idiom guessing from pictures, and idiom solitaire, with both ease of use and configurability:
+- **Number Guessing**: Supports customizable number range (default 0-100), controls Bot participation status by distinguishing group chat/private chat modes
+- **King of Glory Hero Guessing**: Guess King of Glory heroes based on poems/hints, supports three difficulty levels: easy/medium/hard
+- **Idiom Guessing from Pictures**: Guess idioms based on pictures and candidate characters, supports hint function and question switching
+- **Idiom Solitaire**: Compete with Bot in idiom solitaire, automatically return pinyin and meaning of idioms
 
 ## 使用说明 (Usage)
 
 ### 中文
 | 命令 (Command) | 功能说明 (Description) |
 | --- | --- |
-| `guess start` | 启动猜数字游戏，初始范围为配置的最小值-最大值；若 Bot 配置参与，会先随机猜一个数字 |
+| **猜数字游戏** | |
+| `guess start` | 启动猜数字游戏，初始范围为配置的最小值-最大值 |
 | 直接输入数字 | 游戏运行时输入纯数字即可猜测，系统会实时提示“猜大了/猜小了”并缩小范围，或提示“猜对了”并结束游戏 |
 | `guess stop` | 停止当前猜数字游戏，并公布正确数字 |
+| **王者英雄猜谜** | |
+| `wzhero start <难度>` | 启动王者英雄猜谜游戏，难度可选：简单/中等/困难 |
+| 输入英雄名称 | 游戏运行时输入英雄名猜测答案，系统会返回结果提示 |
+| 输入“提示” | 获取当前英雄的线索提示（有次数限制） |
+| `wzhero stop` | 停止当前王者英雄猜谜游戏 |
+| **看图猜成语** | |
+| `cyimage start` | 启动看图猜成语游戏，获取初始题目和图片链接 |
+| 输入成语 | 游戏运行时输入猜测的成语答案 |
+| 输入“提示 [等级]” | 获取当前题目的提示（等级1-5，默认1级） |
+| 输入“下一题” | 切换到下一个猜成语题目 |
+| `cyimage stop` | 停止当前看图猜成语游戏 |
+| **成语接龙** | |
+| `cyjl start` | 启动成语接龙游戏，Bot 先出第一个成语 |
+| 输入“我接<成语>” | 接Bot的成语进行接龙（如：我接一帆风顺） |
+| `cyjl stop` | 停止当前成语接龙游戏 |
 
 ### English
 | Command | Description |
 | --- | --- |
-| `guess start` | Start the number guessing game with the initial range of configured min-max values; if the Bot is configured to participate, it will randomly guess a number first |
+| **Number Guessing Game** | |
+| `guess start` | Start the number guessing game with the initial range of configured min-max values |
 | Enter number directly | Enter a pure number during the game to guess; the system will prompt "too big/too small" in real time and narrow the range, or prompt "correct" and end the game |
 | `guess stop` | Stop the current number guessing game and announce the correct number |
+| **King of Glory Hero Guessing** | |
+| `wzhero start <difficulty>` | Start the King of Glory hero guessing game, difficulty options: easy/medium/hard |
+| Enter hero name | Enter the hero name to guess the answer during the game, the system will return result prompts |
+| Enter "提示" | Get clue hints for the current hero (limited times) |
+| `wzhero stop` | Stop the current King of Glory hero guessing game |
+| **Idiom Guessing from Pictures** | |
+| `cyimage start` | Start the idiom guessing game from pictures, get initial question and image link |
+| Enter idiom | Enter the guessed idiom answer during the game |
+| Enter "提示 [level]" | Get hints for the current question (level 1-5, default level 1) |
+| Enter "下一题" | Switch to the next idiom guessing question |
+| `cyimage stop` | Stop the current idiom guessing game from pictures |
+| **Idiom Solitaire** | |
+| `cyjl start` | Start the idiom solitaire game, Bot will give the first idiom |
+| Enter "我接<idiom>" | Respond to Bot's idiom for solitaire (e.g.: 我接一帆风顺) |
+| `cyjl stop` | Stop the current idiom solitaire game |
 
 ## 配置说明 (Configuration)
 
 ### 中文
 | 配置项 (Config Item) | 说明 (Description) | 默认值 (Default) |
 | --- | --- | --- |
+| **基础功能开关** | | |
+| `enableNumberGuess` | 是否开启猜数字游戏功能 | true |
+| `enableWzHero` | 是否开启王者英雄猜谜游戏功能 | true |
+| `enableChengyuImage` | 是否开启看图猜成语游戏功能 | true |
+| `enableChengyuJielong` | 是否开启成语接龙游戏功能 | true |
+| **猜数字配置** | | |
 | `guessNumber.min` | 猜数字最小值 | 0 |
 | `guessNumber.max` | 猜数字最大值 | 100 |
 | `guessNumber.botParticipateInGroup` | 群聊中 Bot 是否参与猜数字（私聊场景下 Bot 强制参与） | true |
+| **王者英雄猜谜配置** | | |
+| `wzHero.botParticipateInGroup` | 群聊中 Bot 是否参与王者英雄猜谜（私聊场景下 Bot 强制参与） | true |
+| **看图猜成语配置** | | |
+| `chengyuImage.botParticipateInGroup` | 群聊中 Bot 是否参与看图猜成语（私聊场景下 Bot 强制参与） | true |
+| **成语接龙配置** | | |
+| `chengyuJielong.botParticipateInGroup` | 群聊中 Bot 是否参与成语接龙（私聊场景下 Bot 强制参与） | true |
+| **API配置** | | |
+| `apiConfig.wzHeroUserId` | 王者英雄猜谜API的用户区分ID | 1828222534 |
+| `apiConfig.cyjlUserId` | 成语接龙API的用户区分ID | 1828222534 |
+| `apiConfig.timeout` | 第三方API请求超时时间（毫秒） | 5000 |
 
 ### English
 | Config Item | Description | Default |
 | --- | --- | --- |
-| `guessNumber.min` | Minimum value for number guessing| 0 |
+| **Basic Function Switch** | | |
+| `enableNumberGuess` | Whether to enable the number guessing game function | true |
+| `enableWzHero` | Whether to enable the King of Glory hero guessing game function | true |
+| `enableChengyuImage` | Whether to enable the idiom guessing from pictures game function | true |
+| `enableChengyuJielong` | Whether to enable the idiom solitaire game function | true |
+| **Number Guessing Configuration** | | |
+| `guessNumber.min` | Minimum value for number guessing | 0 |
 | `guessNumber.max` | Maximum value for number guessing | 100 |
 | `guessNumber.botParticipateInGroup` | Whether the Bot participates in number guessing in group chats (Bot is forced to participate in private chat scenarios) | true |
+| **King of Glory Hero Guessing Configuration** | | |
+| `wzHero.botParticipateInGroup` | Whether the Bot participates in King of Glory hero guessing in group chats (Bot is forced to participate in private chat scenarios) | true |
+| **Idiom Guessing from Pictures Configuration** | | |
+| `chengyuImage.botParticipateInGroup` | Whether the Bot participates in idiom guessing from pictures in group chats (Bot is forced to participate in private chat scenarios) | true |
+| **Idiom Solitaire Configuration** | | |
+| `chengyuJielong.botParticipateInGroup` | Whether the Bot participates in idiom solitaire in group chats (Bot is forced to participate in private chat scenarios) | true |
+| **API Configuration** | | |
+| `apiConfig.wzHeroUserId` | User ID for King of Glory hero guessing API | 1828222534 |
+| `apiConfig.cyjlUserId` | User ID for idiom solitaire API | 1828222534 |
+| `apiConfig.timeout` | Timeout time for third-party API requests (milliseconds) | 5000 |
 
 ## 项目贡献者 (Contributors)
 | 贡献者 (Contributor) | 贡献内容 (Contribution) |
@@ -58,9 +129,4 @@ This project is licensed under the MIT Open Source License. You are free to use,
 ## 支持我们 (Support Us)
 如果这个项目对您有帮助，欢迎点亮仓库右上角的 Star ⭐ 支持我们，这将是对所有贡献者最大的鼓励！
 
-If this project is helpful to you, please feel free to star the repository in the upper right corner ⭐ to support us, which will be the greatest encouragement to all contributors!
-
-## 问题反馈 (Feedback)
-如有使用问题、功能建议或 Bug 反馈，可通过 GitHub Issues 提交，我们会尽快响应。
-
-If you have any questions or suggestions, please submit them via GitHub Issues, and we will respond as soon as possible.
+If this project is helpful to you, please feel free to star the repository in the upper right corner ⭐ to support us, which will be the greatest encouragement to all contributors!