koishi-plugin-game-mini 0.2.3 → 0.2.4

package/lib/index.js

@@ -161,7 +161,7 @@ exports.Config = koishi_1.Schema.object({
         'enableDice': '启用掷骰子比大小游戏',
         'enableRps': '启用石头剪刀布游戏',
         'enableCalc24': '启用算24点游戏',
-        'enablePasswordLock': '启用密码锁破解游戏',
+        'enablePasswordLock': '启用猜密码游戏',
         'enablePrivateGame': '允许私聊玩游戏',
         'autoPlayDelay': '机器人自动操作延迟（秒）',
         'autoPlayMaxCount': '机器人最大自动操作次数',
@@ -172,9 +172,9 @@ exports.Config = koishi_1.Schema.object({
         'guessNumber.botParticipateInGroup': '群聊中机器人参与猜数字',
         'guessNumber.totalRounds': '猜数字总回合数',
         'guessNumber.showRank': '猜数字显示排行榜',
-        'wzHero': '王者英雄猜谜配置',
-        'wzHero.totalRounds': '王者英雄猜谜总回合数',
-        'wzHero.showRank': '王者英雄猜谜显示排行榜',
+        'wzHero': '猜王者英雄配置',
+        'wzHero.totalRounds': '猜王者英雄总回合数',
+        'wzHero.showRank': '猜王者英雄显示排行榜',
         'chengyuImage': '看图猜成语配置',
         'chengyuImage.totalRounds': '看图猜成语总回合数',
         'chengyuImage.showRank': '看图猜成语显示排行榜',
@@ -194,10 +194,10 @@ exports.Config = koishi_1.Schema.object({
         'calc24.totalRounds': '算24点总回合数',
         'calc24.showRank': '算24点显示排行榜',
         'calc24.numberRange': '算24点数字范围',
-        'passwordLock': '密码锁破解配置',
-        'passwordLock.maxGuessTimes': '密码锁最大猜测次数',
-        'passwordLock.showHint': '密码锁显示提示',
-        'passwordLock.showRank': '密码锁显示排行榜',
+        'passwordLock': '猜密码配置',
+        'passwordLock.maxGuessTimes': '猜密码最大猜测次数',
+        'passwordLock.showHint': '猜密码显示提示',
+        'passwordLock.showRank': '猜密码显示排行榜',
         'apiConfig': 'API接口配置',
         'apiConfig.timeout': '请求超时时间(毫秒)'
     }
@@ -330,7 +330,8 @@ const initState = (key, c) => {
             players: {},
             participants: [],
             numbers: [],
-            playerAnswer: ''
+            playerAnswer: '',
+            solved: false
         },
         passwordLock: {
             started: false,
@@ -342,7 +343,8 @@ const initState = (key, c) => {
             playerGuess: '',
             guessTimes: 0,
             maxGuessTimes: c.passwordLock.maxGuessTimes,
-            hints: []
+            hints: [],
+            solved: false
         }
     };
     gameStates.set(key, s);
@@ -465,19 +467,19 @@ function apply(ctx, cfg) {
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         wzHero: {
-            start: "王者英雄猜谜开始！本次共 {0} 回合～",
-            startUsage: "用法错误！正确用法：王者英雄 开始 [难度] | 王者英雄 [答案] | 王者英雄 提示 | 王者英雄 结束",
-            stop: "王者英雄猜谜比赛已停止",
-            notStarted: "王者英雄猜谜比赛尚未开始，请输入 王者英雄 开始 [难度] 开始游戏",
+            start: "猜王者英雄开始！本次共 {0} 回合～",
+            startUsage: "用法错误！正确用法：猜王者英雄 开始 [难度] | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束",
+            stop: "猜王者英雄比赛已停止",
+            notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 [难度] 开始游戏",
             hint: "提示",
             apiError: "API请求失败，请稍后再试",
             correct: "答对啦！你获得1分～",
             wrong: "答错啦～正确答案是：{0}，你不得分",
             roundEnd: "第 {0} 回合结束！剩余回合：{1}",
-            gameEnd: "🎉 王者英雄猜谜比赛结束！🎉",
+            gameEnd: "🎉 猜王者英雄比赛结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
             rankEmpty: "暂无参与记录～",
-            disabled: "王者英雄猜谜功能已关闭，请联系管理员开启",
+            disabled: "猜王者英雄功能已关闭，请联系管理员开启",
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         chengyuImage: {
@@ -555,8 +557,9 @@ function apply(ctx, cfg) {
             notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
             generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
             correct: "答对啦！你获得1分～",
-            wrong: "答错啦～这组数可以算出24哦！",
-            impossible: "这组数无法算出24！本轮作废～",
+            wrong: "答错啦～",
+            impossible: "这组数无法算出24！本题作废，换一组数字～",
+            solved: "这组数已经被答对啦，换一组数字～",
             roundEnd: "第 {0} 回合结束！剩余回合：{1}",
             gameEnd: "🎉 算24点游戏结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
@@ -565,18 +568,19 @@ function apply(ctx, cfg) {
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         passwordLock: {
-            start: "密码锁破解游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
-            stop: "密码锁破解游戏已停止",
-            notStarted: "密码锁破解游戏尚未开始，请输入 密码锁 开始 开始游戏",
+            start: "猜密码游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
+            stop: "猜密码游戏已停止",
+            notStarted: "猜密码游戏尚未开始，请输入 猜密码 开始 开始游戏",
             guess: "你猜测的密码是：{0}，这是第 {1} 次猜测",
             correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～",
             wrong: "密码错误！{0}",
+            solved: "密码已经被猜出来啦，游戏结束～",
             noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
             invalidPassword: "无效的密码！请输入4位数字",
-            gameEnd: "🎉 密码锁破解游戏结束！🎉",
+            gameEnd: "🎉 猜密码游戏结束！🎉",
             rankTitle: "🏆 排行榜 🏆",
             rankEmpty: "暂无参与记录～",
-            disabled: "密码锁破解功能已关闭，请联系管理员开启",
+            disabled: "猜密码功能已关闭，请联系管理员开启",
             autoStop: "游戏因长时间无人操作，已自动结束"
         },
         common: {
@@ -879,6 +883,12 @@ function apply(ctx, cfg) {
                 st.wzHero.players[playerKey] = getPlayerData(session);
                 st.wzHero.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.wzHero);
+                await session.send(d.wzHero.stop);
+                gameStates.set(key, st);
+                return;
+            }
             try {
                 const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
                     params: { id: getIntUserId(session), msg: content }, timeout: cfg.apiConfig.timeout
@@ -941,6 +951,12 @@ function apply(ctx, cfg) {
                 st.guessNumber.players[playerKey] = getPlayerData(session);
                 st.guessNumber.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.guessNumber);
+                await session.send(d.guessNumber.stop);
+                gameStates.set(key, st);
+                return;
+            }
             const num = parseInt(content);
             if (isNaN(num)) {
                 setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
@@ -984,29 +1000,29 @@ function apply(ctx, cfg) {
                 st.dice.players[playerKey] = getPlayerData(session);
                 st.dice.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.dice);
+                await session.send(d.dice.stop);
+                gameStates.set(key, st);
+                return;
+            }
             if (content !== '掷骰子') {
                 setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
                 return next();
             }
             st.dice.playerDice = koishi_1.Random.int(1, 6);
-            st.dice.botDice = cfg.dice.botParticipate ? koishi_1.Random.int(1, 6) : 0;
+            st.dice.botDice = koishi_1.Random.int(1, 6);
             let resultMsg = d.dice.roll.replace('{0}', st.dice.playerDice.toString()).replace('{1}', st.dice.botDice.toString());
-            if (cfg.dice.botParticipate) {
-                if (st.dice.playerDice > st.dice.botDice) {
-                    resultMsg += '\n' + d.dice.win;
-                    st.dice.players[playerKey].score += 1;
-                    st.dice.players[playerKey].correctCount += 1;
-                }
-                else if (st.dice.playerDice < st.dice.botDice) {
-                    resultMsg += '\n' + d.dice.lose;
-                }
-                else {
-                    resultMsg += '\n' + d.dice.draw;
-                }
+            if (st.dice.playerDice > st.dice.botDice) {
+                resultMsg += '\n' + d.dice.win;
+                st.dice.players[playerKey].score += 1;
+                st.dice.players[playerKey].correctCount += 1;
+            }
+            else if (st.dice.playerDice < st.dice.botDice) {
+                resultMsg += '\n' + d.dice.lose;
             }
             else {
-                resultMsg += '\n你掷出了 ' + st.dice.playerDice + ' 点！';
-                st.dice.players[playerKey].score += 1;
+                resultMsg += '\n' + d.dice.draw;
             }
             await session.send(resultMsg);
             st.dice.currentRound += 1;
@@ -1033,32 +1049,32 @@ function apply(ctx, cfg) {
                 st.rps.players[playerKey] = getPlayerData(session);
                 st.rps.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.rps);
+                await session.send(d.rps.stop);
+                gameStates.set(key, st);
+                return;
+            }
             if (!st.rps.choices.includes(content)) {
                 await session.send(d.rps.invalidChoice);
                 setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
-                return next();
+                return;
             }
             st.rps.playerChoice = content;
-            st.rps.botChoice = cfg.rps.botParticipate ? st.rps.choices[koishi_1.Random.int(0, 2)] : '';
+            st.rps.botChoice = st.rps.choices[koishi_1.Random.int(0, 2)];
             let resultMsg = d.rps.choice.replace('{0}', st.rps.playerChoice).replace('{1}', st.rps.botChoice);
-            if (cfg.rps.botParticipate) {
-                if ((st.rps.playerChoice === '石头' && st.rps.botChoice === '剪刀') ||
-                    (st.rps.playerChoice === '剪刀' && st.rps.botChoice === '布') ||
-                    (st.rps.playerChoice === '布' && st.rps.botChoice === '石头')) {
-                    resultMsg += '\n' + d.rps.win;
-                    st.rps.players[playerKey].score += 1;
-                    st.rps.players[playerKey].correctCount += 1;
-                }
-                else if (st.rps.playerChoice === st.rps.botChoice) {
-                    resultMsg += '\n' + d.rps.draw;
-                }
-                else {
-                    resultMsg += '\n' + d.rps.lose;
-                }
+            if ((st.rps.playerChoice === '石头' && st.rps.botChoice === '剪刀') ||
+                (st.rps.playerChoice === '剪刀' && st.rps.botChoice === '布') ||
+                (st.rps.playerChoice === '布' && st.rps.botChoice === '石头')) {
+                resultMsg += '\n' + d.rps.win;
+                st.rps.players[playerKey].score += 1;
+                st.rps.players[playerKey].correctCount += 1;
+            }
+            else if (st.rps.playerChoice === st.rps.botChoice) {
+                resultMsg += '\n' + d.rps.draw;
             }
             else {
-                resultMsg += '\n你选择了 ' + st.rps.playerChoice + '！';
-                st.rps.players[playerKey].score += 1;
+                resultMsg += '\n' + d.rps.lose;
             }
             await session.send(resultMsg);
             st.rps.currentRound += 1;
@@ -1085,19 +1101,44 @@ function apply(ctx, cfg) {
                 st.calc24.players[playerKey] = getPlayerData(session);
                 st.calc24.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.calc24);
+                await session.send(d.calc24.stop);
+                gameStates.set(key, st);
+                return;
+            }
             if (content === '换题') {
-                st.calc24.numbers = [];
-                for (let i = 0; i < 4; i++) {
-                    st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
+                if (!st.calc24.solved) {
+                    st.calc24.numbers = [];
+                    for (let i = 0; i < 4; i++) {
+                        st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
+                    }
+                    st.calc24.solved = false;
+                    const canCalculate = calculate24([...st.calc24.numbers]);
+                    if (!canCalculate) {
+                        await session.send(d.calc24.impossible);
+                    }
+                    else {
+                        await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+                    }
                 }
-                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
                 setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
-                return next();
+                return;
+            }
+            if (st.calc24.solved) {
+                await session.send(d.calc24.solved);
+                setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
+                return;
             }
             st.calc24.playerAnswer = content;
             const canCalculate = calculate24([...st.calc24.numbers]);
             if (!canCalculate) {
                 await session.send(d.calc24.impossible);
+                st.calc24.numbers = [];
+                for (let i = 0; i < 4; i++) {
+                    st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
+                }
+                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
             }
             else {
                 try {
@@ -1106,6 +1147,33 @@ function apply(ctx, cfg) {
                         await session.send(d.calc24.correct);
                         st.calc24.players[playerKey].score += 1;
                         st.calc24.players[playerKey].correctCount += 1;
+                        st.calc24.solved = true;
+                        st.calc24.currentRound += 1;
+                        if (st.calc24.currentRound > st.calc24.totalRounds) {
+                            st.calc24.started = false;
+                            clearGameTimer(st.calc24);
+                            await session.send(d.calc24.gameEnd);
+                            if (cfg.calc24.showRank && !isPrivate(session)) {
+                                const rankText = generateRankText(st.calc24.players);
+                                await session.send(rankText);
+                            }
+                            clearGameData(st.calc24);
+                        }
+                        else {
+                            await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
+                            st.calc24.numbers = [];
+                            for (let i = 0; i < 4; i++) {
+                                st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
+                            }
+                            st.calc24.solved = false;
+                            const nextCanCalculate = calculate24([...st.calc24.numbers]);
+                            if (!nextCanCalculate) {
+                                await session.send(d.calc24.impossible);
+                            }
+                            else {
+                                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+                            }
+                        }
                     }
                     else {
                         await session.send(d.calc24.wrong);
@@ -1115,25 +1183,6 @@ function apply(ctx, cfg) {
                     await session.send(d.calc24.wrong);
                 }
             }
-            st.calc24.currentRound += 1;
-            if (st.calc24.currentRound > st.calc24.totalRounds) {
-                st.calc24.started = false;
-                clearGameTimer(st.calc24);
-                await session.send(d.calc24.gameEnd);
-                if (cfg.calc24.showRank && !isPrivate(session)) {
-                    const rankText = generateRankText(st.calc24.players);
-                    await session.send(rankText);
-                }
-                clearGameData(st.calc24);
-            }
-            else {
-                st.calc24.numbers = [];
-                for (let i = 0; i < 4; i++) {
-                    st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
-                }
-                await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
-                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
-            }
             setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
             gameStates.set(key, st);
             return;
@@ -1144,10 +1193,21 @@ function apply(ctx, cfg) {
                 st.passwordLock.players[playerKey] = getPlayerData(session);
                 st.passwordLock.participants.push(playerKey);
             }
+            if (content === '结束') {
+                clearGameData(st.passwordLock);
+                await session.send(d.passwordLock.stop);
+                gameStates.set(key, st);
+                return;
+            }
+            if (st.passwordLock.solved) {
+                await session.send(d.passwordLock.solved);
+                setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
+                return;
+            }
             if (!/^\d{4}$/.test(content)) {
                 await session.send(d.passwordLock.invalidPassword);
                 setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
-                return next();
+                return;
             }
             st.passwordLock.playerGuess = content;
             st.passwordLock.guessTimes += 1;
@@ -1156,6 +1216,7 @@ function apply(ctx, cfg) {
                 await session.send(d.passwordLock.correct.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
                 st.passwordLock.players[playerKey].score += 10 - (st.passwordLock.guessTimes - 1);
                 st.passwordLock.players[playerKey].correctCount += 1;
+                st.passwordLock.solved = true;
                 st.passwordLock.started = false;
                 clearGameTimer(st.passwordLock);
                 await session.send(d.passwordLock.gameEnd);
@@ -1199,7 +1260,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'guessNumber')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1223,14 +1284,14 @@ function apply(ctx, cfg) {
             await session.send(d.guessNumber.usage);
         }
     });
-    ctx.command('王者英雄 <action> [param]', '王者英雄猜谜')
+    ctx.command('猜王者英雄 <action> [param]', '猜王者英雄猜谜')
         .action(async (argv, action, param) => {
         const session = argv.session;
         if (!session)
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'wzHero')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1272,7 +1333,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'chengyuImage')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1320,7 +1381,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'chengyuJielong')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1350,7 +1411,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'dice')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1366,6 +1427,9 @@ function apply(ctx, cfg) {
             await session.send(d.dice.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：掷骰子 开始 或 掷骰子 结束');
+        }
     });
     ctx.command('石头剪刀布 <action>', '石头剪刀布')
         .action(async (argv, action) => {
@@ -1374,7 +1438,7 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'rps')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1390,6 +1454,9 @@ function apply(ctx, cfg) {
             await session.send(d.rps.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：石头剪刀布 开始 或 石头剪刀布 结束');
+        }
     });
     ctx.command('算24点 <action>', '算24点游戏')
         .action(async (argv, action) => {
@@ -1398,19 +1465,26 @@ function apply(ctx, cfg) {
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'calc24')) {
             await session.send(d.common.gameRunning);
             return;
         }
         if (action === '开始') {
             st.calc24.started = true;
             st.calc24.currentRound = 1;
+            st.calc24.solved = false;
             st.calc24.numbers = [];
             for (let i = 0; i < 4; i++) {
                 st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
             }
             await session.send(d.calc24.start.replace('{0}', st.calc24.totalRounds.toString()));
-            await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+            const canCalculate = calculate24([...st.calc24.numbers]);
+            if (!canCalculate) {
+                await session.send(d.calc24.impossible);
+            }
+            else {
+                await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
+            }
             gameStates.set(key, st);
             setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
         }
@@ -1419,15 +1493,18 @@ function apply(ctx, cfg) {
             await session.send(d.calc24.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：算24点 开始 或 算24点 结束');
+        }
     });
-    ctx.command('密码锁 <action>', '密码锁破解')
+    ctx.command('猜密码 <action>', '猜密码游戏')
         .action(async (argv, action) => {
         const session = argv.session;
         if (!session)
             return;
         const key = getSessionKey(session);
         const st = gameStates.get(key) || initState(key, cfg);
-        if (checkGameRunning(st)) {
+        if (checkGameRunning(st, 'passwordLock')) {
             await session.send(d.common.gameRunning);
             return;
         }
@@ -1435,6 +1512,7 @@ function apply(ctx, cfg) {
             st.passwordLock.started = true;
             st.passwordLock.currentRound = 1;
             st.passwordLock.guessTimes = 0;
+            st.passwordLock.solved = false;
             st.passwordLock.password = koishi_1.Random.int(1000, 9999).toString();
             await session.send(d.passwordLock.start.replace('{0}', st.passwordLock.maxGuessTimes.toString()));
             gameStates.set(key, st);
@@ -1445,5 +1523,8 @@ function apply(ctx, cfg) {
             await session.send(d.passwordLock.stop);
             gameStates.set(key, st);
         }
+        else {
+            await session.send('请输入：猜密码 开始 或 猜密码 结束');
+        }
     });
 }

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

@@ -14,19 +14,19 @@ guessNumber:
   autoStop: "游戏因长时间无人操作，已自动结束"
 
 wzHero:
-  start: "王者英雄猜谜开始！本次共 {0} 回合～"
-  startUsage: "用法错误！正确用法：王者英雄 开始 [难度] | 王者英雄 [答案] | 王者英雄 提示 | 王者英雄 结束"
-  stop: "王者英雄猜谜比赛已停止"
-  notStarted: "王者英雄猜谜比赛尚未开始，请输入 王者英雄 开始 [难度] 开始游戏"
+  start: "猜王者英雄开始！本次共 {0} 回合～"
+  startUsage: "用法错误！正确用法：猜王者英雄 开始 [难度] | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束"
+  stop: "猜王者英雄比赛已停止"
+  notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 [难度] 开始游戏"
   hint: "提示"
   apiError: "API请求失败，请稍后再试"
   correct: "答对啦！你获得1分～"
   wrong: "答错啦～正确答案是：{0}，你不得分"
   roundEnd: "第 {0} 回合结束！剩余回合：{1}"
-  gameEnd: "🎉 王者英雄猜谜比赛结束！🎉"
+  gameEnd: "🎉 猜王者英雄比赛结束！🎉"
   rankTitle: "🏆 排行榜 🏆"
   rankEmpty: "暂无参与记录～"
-  disabled: "王者英雄猜谜功能已关闭，请联系管理员开启"
+  disabled: "猜王者英雄功能已关闭，请联系管理员开启"
   autoStop: "游戏因长时间无人操作，已自动结束"
 
 chengyuImage:
@@ -104,8 +104,9 @@ calc24:
   notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏"
   generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！"
   correct: "答对啦！你获得1分～"
-  wrong: "答错啦～这组数可以算出24哦！"
-  impossible: "这组数无法算出24！本轮作废～"
+  wrong: "答错啦～"
+  impossible: "这组数无法算出24！本题作废，换一组数字～"
+  solved: "这组数已经被答对啦，换一组数字～"
   roundEnd: "第 {0} 回合结束！剩余回合：{1}"
   gameEnd: "🎉 算24点游戏结束！🎉"
   rankTitle: "🏆 排行榜 🏆"
@@ -114,18 +115,19 @@ calc24:
   autoStop: "游戏因长时间无人操作，已自动结束"
 
 passwordLock:
-  start: "密码锁破解游戏开始！密码为4位数字，你有 {0} 次猜测机会～"
-  stop: "密码锁破解游戏已停止"
-  notStarted: "密码锁破解游戏尚未开始，请输入 密码锁 开始 开始游戏"
+  start: "猜密码游戏开始！密码为4位数字，你有 {0} 次猜测机会～"
+  stop: "猜密码游戏已停止"
+  notStarted: "猜密码游戏尚未开始，请输入 猜密码 开始 开始游戏"
   guess: "你猜测的密码是：{0}，这是第 {1} 次猜测"
   correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～"
   wrong: "密码错误！{0}"
+  solved: "密码已经被猜出来啦，游戏结束～"
   noChance: "❌ 没有猜测机会了！正确密码是：{0}～"
   invalidPassword: "无效的密码！请输入4位数字"
-  gameEnd: "🎉 密码锁破解游戏结束！🎉"
+  gameEnd: "🎉 猜密码游戏结束！🎉"
   rankTitle: "🏆 排行榜 🏆"
   rankEmpty: "暂无参与记录～"
-  disabled: "密码锁破解功能已关闭，请联系管理员开启"
+  disabled: "猜密码功能已关闭，请联系管理员开启"
   autoStop: "游戏因长时间无人操作，已自动结束"
 
 common:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-game-mini",
-  "version": "0.2.3",
-  "description": "一款包含猜数字、猜王者英雄、看图猜成语、成语接龙的多功能小游戏插件",
+  "version": "0.2.4",
+  "description": "多功能小游戏合集：猜数字、猜王者英雄、看图猜成语、成语接龙、掷骰子、石头剪刀布、算24点、猜密码",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -12,12 +12,21 @@
   },
   "keywords": [
     "koishi",
-    "plugin",
+    "koishi-plugin",
     "game",
+    "mini-game",
     "猜数字",
+    "猜王者英雄",
     "王者荣耀",
-    "猜成语",
-    "成语接龙"
+    "看图猜成语",
+    "成语接龙",
+    "掷骰子",
+    "石头剪刀布",
+    "算24点",
+    "24点",
+    "猜密码",
+    "密码锁",
+    "小游戏"
   ],
   "author": "Minecraft-1314",
   "license": "MIT",