koishi-plugin-game-mini 0.2.1 → 0.2.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/lib/index.d.ts +24 -2
  2. package/lib/index.js +812 -300
  3. package/lib/locales/locales/zh-CN.yml +72 -38
  4. package/package.json +1 -1
package/lib/index.js CHANGED
@@ -15,117 +15,189 @@ exports.using = ['i18n'];
15
15
  exports.inject = ['console'];
16
16
  exports.Config = koishi_1.Schema.object({
17
17
  enableNumberGuess: koishi_1.Schema.boolean().default(true)
18
- .description('是否启用猜数字游戏')
18
+ .description('启用猜数字游戏')
19
19
  .i18n({ 'zh-CN': '启用猜数字游戏' }),
20
20
  enableWzHero: koishi_1.Schema.boolean().default(true)
21
- .description('是否启用王者英雄猜谜游戏')
22
- .i18n({ 'zh-CN': '启用王者英雄猜谜' }),
21
+ .description('启用王者英雄猜谜游戏')
22
+ .i18n({ 'zh-CN': '启用王者英雄猜谜游戏' }),
23
23
  enableChengyuImage: koishi_1.Schema.boolean().default(true)
24
- .description('是否启用看图猜成语游戏')
25
- .i18n({ 'zh-CN': '启用看图猜成语' }),
24
+ .description('启用看图猜成语游戏')
25
+ .i18n({ 'zh-CN': '启用看图猜成语游戏' }),
26
26
  enableChengyuJielong: koishi_1.Schema.boolean().default(true)
27
- .description('是否启用成语接龙游戏')
28
- .i18n({ 'zh-CN': '启用成语接龙' }),
27
+ .description('启用成语接龙游戏')
28
+ .i18n({ 'zh-CN': '启用成语接龙游戏' }),
29
+ enableDice: koishi_1.Schema.boolean().default(true)
30
+ .description('启用掷骰子比大小游戏')
31
+ .i18n({ 'zh-CN': '启用掷骰子比大小游戏' }),
32
+ enableRps: koishi_1.Schema.boolean().default(true)
33
+ .description('启用石头剪刀布游戏')
34
+ .i18n({ 'zh-CN': '启用石头剪刀布游戏' }),
35
+ enableCalc24: koishi_1.Schema.boolean().default(true)
36
+ .description('启用算24点游戏')
37
+ .i18n({ 'zh-CN': '启用算24点游戏' }),
38
+ enablePasswordLock: koishi_1.Schema.boolean().default(true)
39
+ .description('启用密码锁破解游戏')
40
+ .i18n({ 'zh-CN': '启用密码锁破解游戏' }),
29
41
  enablePrivateGame: koishi_1.Schema.boolean().default(true)
30
- .description('是否允许私聊玩游戏')
42
+ .description('允许私聊玩游戏')
31
43
  .i18n({ 'zh-CN': '允许私聊玩游戏' }),
32
44
  autoPlayDelay: koishi_1.Schema.number().min(0).default(10)
33
- .description('成语接龙机器人自动接龙延迟（秒）')
34
- .i18n({ 'zh-CN': '机器人自动接龙延迟(秒)' }),
45
+ .description('机器人自动操作延迟（秒）')
46
+ .i18n({ 'zh-CN': '机器人自动操作延迟（秒）' }),
35
47
  autoPlayMaxCount: koishi_1.Schema.number().min(1).default(5)
36
- .description('成语接龙机器人最大自动接龙次数')
37
- .i18n({ 'zh-CN': '机器人最大自动接龙次数' }),
48
+ .description('机器人最大自动操作次数')
49
+ .i18n({ 'zh-CN': '机器人最大自动操作次数' }),
38
50
  autoStopInactiveTime: koishi_1.Schema.number().min(0).default(30)
39
51
  .description('游戏无操作自动停止时间（秒）')
40
- .i18n({ 'zh-CN': '无操作自动停止时间(秒)' }),
52
+ .i18n({ 'zh-CN': '游戏无操作自动停止时间（秒）' }),
41
53
  guessNumber: koishi_1.Schema.object({
42
54
  min: koishi_1.Schema.number().min(0).default(0)
43
55
  .description('猜数字最小值')
44
- .i18n({ 'zh-CN': '最小值' }),
56
+ .i18n({ 'zh-CN': '猜数字最小值' }),
45
57
  max: koishi_1.Schema.number().min(1).default(100)
46
58
  .description('猜数字最大值')
47
- .i18n({ 'zh-CN': '最大值' }),
59
+ .i18n({ 'zh-CN': '猜数字最大值' }),
48
60
  botParticipateInGroup: koishi_1.Schema.boolean().default(true)
49
- .description('群聊中机器人是否参与猜数字')
50
- .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
61
+ .description('群聊中机器人参与猜数字')
62
+ .i18n({ 'zh-CN': '群聊中机器人参与猜数字' }),
51
63
  totalRounds: koishi_1.Schema.number().min(1).default(10)
52
64
  .description('猜数字总回合数')
53
- .i18n({ 'zh-CN': '总回合数' }),
65
+ .i18n({ 'zh-CN': '猜数字总回合数' }),
54
66
  showRank: koishi_1.Schema.boolean().default(true)
55
- .description('游戏结束后是否显示排行榜')
56
- .i18n({ 'zh-CN': '显示排行榜' }),
67
+ .description('猜数字显示排行榜')
68
+ .i18n({ 'zh-CN': '猜数字显示排行榜' }),
57
69
  }).description('猜数字游戏配置')
58
70
  .i18n({ 'zh-CN': '猜数字游戏配置' }),
59
71
  wzHero: koishi_1.Schema.object({
60
- botParticipateInGroup: koishi_1.Schema.boolean().default(false)
61
- .description('群聊中机器人是否参与王者英雄猜谜')
62
- .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
63
72
  totalRounds: koishi_1.Schema.number().min(1).default(10)
64
73
  .description('王者英雄猜谜总回合数')
65
- .i18n({ 'zh-CN': '总回合数' }),
74
+ .i18n({ 'zh-CN': '王者英雄猜谜总回合数' }),
66
75
  showRank: koishi_1.Schema.boolean().default(true)
67
- .description('游戏结束后是否显示排行榜')
68
- .i18n({ 'zh-CN': '显示排行榜' }),
76
+ .description('王者英雄猜谜显示排行榜')
77
+ .i18n({ 'zh-CN': '王者英雄猜谜显示排行榜' }),
69
78
  }).description('王者英雄猜谜游戏配置')
70
- .i18n({ 'zh-CN': '王者英雄猜谜配置' }),
79
+ .i18n({ 'zh-CN': '王者英雄猜谜游戏配置' }),
71
80
  chengyuImage: koishi_1.Schema.object({
72
- botParticipateInGroup: koishi_1.Schema.boolean().default(false)
73
- .description('群聊中机器人是否参与看图猜成语')
74
- .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
75
81
  totalRounds: koishi_1.Schema.number().min(1).default(10)
76
82
  .description('看图猜成语总回合数')
77
- .i18n({ 'zh-CN': '总回合数' }),
83
+ .i18n({ 'zh-CN': '看图猜成语总回合数' }),
78
84
  showRank: koishi_1.Schema.boolean().default(true)
79
- .description('游戏结束后是否显示排行榜')
80
- .i18n({ 'zh-CN': '显示排行榜' }),
85
+ .description('看图猜成语显示排行榜')
86
+ .i18n({ 'zh-CN': '看图猜成语显示排行榜' }),
81
87
  }).description('看图猜成语游戏配置')
82
- .i18n({ 'zh-CN': '看图猜成语配置' }),
88
+ .i18n({ 'zh-CN': '看图猜成语游戏配置' }),
83
89
  chengyuJielong: koishi_1.Schema.object({
84
90
  botParticipateInGroup: koishi_1.Schema.boolean().default(true)
85
- .description('群聊中机器人是否参与成语接龙')
86
- .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
91
+ .description('群聊中机器人参与成语接龙')
92
+ .i18n({ 'zh-CN': '群聊中机器人参与成语接龙' }),
87
93
  totalRounds: koishi_1.Schema.number().min(1).default(10)
88
94
  .description('成语接龙总回合数')
89
- .i18n({ 'zh-CN': '总回合数' }),
95
+ .i18n({ 'zh-CN': '成语接龙总回合数' }),
90
96
  showRank: koishi_1.Schema.boolean().default(true)
91
- .description('游戏结束后是否显示排行榜')
92
- .i18n({ 'zh-CN': '显示排行榜' }),
97
+ .description('成语接龙显示排行榜')
98
+ .i18n({ 'zh-CN': '成语接龙显示排行榜' }),
93
99
  }).description('成语接龙游戏配置')
94
- .i18n({ 'zh-CN': '成语接龙配置' }),
100
+ .i18n({ 'zh-CN': '成语接龙游戏配置' }),
101
+ dice: koishi_1.Schema.object({
102
+ totalRounds: koishi_1.Schema.number().min(1).default(5)
103
+ .description('掷骰子总回合数')
104
+ .i18n({ 'zh-CN': '掷骰子总回合数' }),
105
+ showRank: koishi_1.Schema.boolean().default(true)
106
+ .description('掷骰子显示排行榜')
107
+ .i18n({ 'zh-CN': '掷骰子显示排行榜' }),
108
+ botParticipate: koishi_1.Schema.boolean().default(true)
109
+ .description('机器人参与掷骰子')
110
+ .i18n({ 'zh-CN': '机器人参与掷骰子' }),
111
+ }).description('掷骰子比大小游戏配置')
112
+ .i18n({ 'zh-CN': '掷骰子比大小游戏配置' }),
113
+ rps: koishi_1.Schema.object({
114
+ totalRounds: koishi_1.Schema.number().min(1).default(5)
115
+ .description('石头剪刀布总回合数')
116
+ .i18n({ 'zh-CN': '石头剪刀布总回合数' }),
117
+ showRank: koishi_1.Schema.boolean().default(true)
118
+ .description('石头剪刀布显示排行榜')
119
+ .i18n({ 'zh-CN': '石头剪刀布显示排行榜' }),
120
+ botParticipate: koishi_1.Schema.boolean().default(true)
121
+ .description('机器人参与石头剪刀布')
122
+ .i18n({ 'zh-CN': '机器人参与石头剪刀布' }),
123
+ }).description('石头剪刀布游戏配置')
124
+ .i18n({ 'zh-CN': '石头剪刀布游戏配置' }),
125
+ calc24: koishi_1.Schema.object({
126
+ totalRounds: koishi_1.Schema.number().min(1).default(5)
127
+ .description('算24点总回合数')
128
+ .i18n({ 'zh-CN': '算24点总回合数' }),
129
+ showRank: koishi_1.Schema.boolean().default(true)
130
+ .description('算24点显示排行榜')
131
+ .i18n({ 'zh-CN': '算24点显示排行榜' }),
132
+ numberRange: koishi_1.Schema.array(koishi_1.Schema.number()).default([1, 13])
133
+ .description('算24点数字范围 [最小值, 最大值]')
134
+ .i18n({ 'zh-CN': '算24点数字范围 [最小值, 最大值]' }),
135
+ }).description('算24点游戏配置')
136
+ .i18n({ 'zh-CN': '算24点游戏配置' }),
137
+ passwordLock: koishi_1.Schema.object({
138
+ maxGuessTimes: koishi_1.Schema.number().min(1).default(10)
139
+ .description('密码锁最大猜测次数')
140
+ .i18n({ 'zh-CN': '密码锁最大猜测次数' }),
141
+ showHint: koishi_1.Schema.boolean().default(true)
142
+ .description('密码锁显示提示')
143
+ .i18n({ 'zh-CN': '密码锁显示提示' }),
144
+ showRank: koishi_1.Schema.boolean().default(true)
145
+ .description('密码锁显示排行榜')
146
+ .i18n({ 'zh-CN': '密码锁显示排行榜' }),
147
+ }).description('密码锁破解游戏配置')
148
+ .i18n({ 'zh-CN': '密码锁破解游戏配置' }),
95
149
  apiConfig: koishi_1.Schema.object({
96
150
  timeout: koishi_1.Schema.number().default(5000)
97
151
  .description('API请求超时时间（毫秒）')
98
- .i18n({ 'zh-CN': '请求超时时间(毫秒)' }),
152
+ .i18n({ 'zh-CN': 'API请求超时时间（毫秒）' }),
99
153
  }).description('API接口配置')
100
154
  .i18n({ 'zh-CN': 'API接口配置' }),
101
155
  }).i18n({
102
156
  'zh-CN': {
103
157
  'enableNumberGuess': '启用猜数字游戏',
104
- 'enableWzHero': '启用王者英雄猜谜',
105
- 'enableChengyuImage': '启用看图猜成语',
106
- 'enableChengyuJielong': '启用成语接龙',
158
+ 'enableWzHero': '启用王者英雄猜谜游戏',
159
+ 'enableChengyuImage': '启用看图猜成语游戏',
160
+ 'enableChengyuJielong': '启用成语接龙游戏',
161
+ 'enableDice': '启用掷骰子比大小游戏',
162
+ 'enableRps': '启用石头剪刀布游戏',
163
+ 'enableCalc24': '启用算24点游戏',
164
+ 'enablePasswordLock': '启用密码锁破解游戏',
107
165
  'enablePrivateGame': '允许私聊玩游戏',
108
- 'autoPlayDelay': '机器人自动接龙延迟(秒)',
109
- 'autoPlayMaxCount': '机器人最大自动接龙次数',
110
- 'autoStopInactiveTime': '无操作自动停止时间(秒)',
166
+ 'autoPlayDelay': '机器人自动操作延迟（秒）',
167
+ 'autoPlayMaxCount': '机器人最大自动操作次数',
168
+ 'autoStopInactiveTime': '游戏无操作自动停止时间（秒）',
111
169
  'guessNumber': '猜数字游戏配置',
112
- 'guessNumber.min': '最小值',
113
- 'guessNumber.max': '最大值',
114
- 'guessNumber.botParticipateInGroup': '机器人参与群聊游戏',
115
- 'guessNumber.totalRounds': '总回合数',
116
- 'guessNumber.showRank': '显示排行榜',
170
+ 'guessNumber.min': '猜数字最小值',
171
+ 'guessNumber.max': '猜数字最大值',
172
+ 'guessNumber.botParticipateInGroup': '群聊中机器人参与猜数字',
173
+ 'guessNumber.totalRounds': '猜数字总回合数',
174
+ 'guessNumber.showRank': '猜数字显示排行榜',
117
175
  'wzHero': '王者英雄猜谜配置',
118
- 'wzHero.botParticipateInGroup': '机器人参与群聊游戏',
119
- 'wzHero.totalRounds': '总回合数',
120
- 'wzHero.showRank': '显示排行榜',
176
+ 'wzHero.totalRounds': '王者英雄猜谜总回合数',
177
+ 'wzHero.showRank': '王者英雄猜谜显示排行榜',
121
178
  'chengyuImage': '看图猜成语配置',
122
- 'chengyuImage.botParticipateInGroup': '机器人参与群聊游戏',
123
- 'chengyuImage.totalRounds': '总回合数',
124
- 'chengyuImage.showRank': '显示排行榜',
179
+ 'chengyuImage.totalRounds': '看图猜成语总回合数',
180
+ 'chengyuImage.showRank': '看图猜成语显示排行榜',
125
181
  'chengyuJielong': '成语接龙配置',
126
- 'chengyuJielong.botParticipateInGroup': '机器人参与群聊游戏',
127
- 'chengyuJielong.totalRounds': '总回合数',
128
- 'chengyuJielong.showRank': '显示排行榜',
182
+ 'chengyuJielong.botParticipateInGroup': '群聊中机器人参与成语接龙',
183
+ 'chengyuJielong.totalRounds': '成语接龙总回合数',
184
+ 'chengyuJielong.showRank': '成语接龙显示排行榜',
185
+ 'dice': '掷骰子比大小配置',
186
+ 'dice.totalRounds': '掷骰子总回合数',
187
+ 'dice.showRank': '掷骰子显示排行榜',
188
+ 'dice.botParticipate': '机器人参与掷骰子',
189
+ 'rps': '石头剪刀布配置',
190
+ 'rps.totalRounds': '石头剪刀布总回合数',
191
+ 'rps.showRank': '石头剪刀布显示排行榜',
192
+ 'rps.botParticipate': '机器人参与石头剪刀布',
193
+ 'calc24': '算24点配置',
194
+ 'calc24.totalRounds': '算24点总回合数',
195
+ 'calc24.showRank': '算24点显示排行榜',
196
+ 'calc24.numberRange': '算24点数字范围',
197
+ 'passwordLock': '密码锁破解配置',
198
+ 'passwordLock.maxGuessTimes': '密码锁最大猜测次数',
199
+ 'passwordLock.showHint': '密码锁显示提示',
200
+ 'passwordLock.showRank': '密码锁显示排行榜',
129
201
  'apiConfig': 'API接口配置',
130
202
  'apiConfig.timeout': '请求超时时间(毫秒)'
131
203
  }
@@ -157,13 +229,31 @@ const checkGameRunning = (s, t) => {
157
229
  return true;
158
230
  if (t !== 'chengyuJielong' && s.chengyuJielong.started)
159
231
  return true;
232
+ if (t !== 'dice' && s.dice.started)
233
+ return true;
234
+ if (t !== 'rps' && s.rps.started)
235
+ return true;
236
+ if (t !== 'calc24' && s.calc24.started)
237
+ return true;
238
+ if (t !== 'passwordLock' && s.passwordLock.started)
239
+ return true;
160
240
  return false;
161
241
  };
242
+ const clearGameTimer = (state) => {
243
+ if (state.stopTimer)
244
+ clearTimeout(state.stopTimer);
245
+ };
162
246
  const clearAllTimers = (st) => {
247
+ clearGameTimer(st.guessNumber);
248
+ clearGameTimer(st.wzHero);
249
+ clearGameTimer(st.chengyuImage);
250
+ clearGameTimer(st.chengyuJielong);
251
+ clearGameTimer(st.dice);
252
+ clearGameTimer(st.rps);
253
+ clearGameTimer(st.calc24);
254
+ clearGameTimer(st.passwordLock);
163
255
  if (st.chengyuJielong.autoPlayTimer)
164
256
  clearTimeout(st.chengyuJielong.autoPlayTimer);
165
- if (st.chengyuJielong.stopTimer)
166
- clearTimeout(st.chengyuJielong.stopTimer);
167
257
  };
168
258
  const initState = (key, c) => {
169
259
  const s = {
@@ -211,8 +301,49 @@ const initState = (key, c) => {
211
301
  botTurn: true,
212
302
  autoPlayCount: 0,
213
303
  hasTriggeredAutoPlay: false,
214
- lastActiveTime: Date.now()
304
+ lastActiveTime: Date.now(),
305
+ autoPlayTimer: undefined
306
+ },
307
+ dice: {
308
+ started: false,
309
+ totalRounds: c.dice.totalRounds,
310
+ currentRound: 0,
311
+ players: {},
312
+ participants: [],
313
+ playerDice: 0,
314
+ botDice: 0
215
315
  },
316
+ rps: {
317
+ started: false,
318
+ totalRounds: c.rps.totalRounds,
319
+ currentRound: 0,
320
+ players: {},
321
+ participants: [],
322
+ playerChoice: '',
323
+ botChoice: '',
324
+ choices: ['石头', '剪刀', '布']
325
+ },
326
+ calc24: {
327
+ started: false,
328
+ totalRounds: c.calc24.totalRounds,
329
+ currentRound: 0,
330
+ players: {},
331
+ participants: [],
332
+ numbers: [],
333
+ playerAnswer: ''
334
+ },
335
+ passwordLock: {
336
+ started: false,
337
+ totalRounds: 1,
338
+ currentRound: 0,
339
+ players: {},
340
+ participants: [],
341
+ password: '',
342
+ playerGuess: '',
343
+ guessTimes: 0,
344
+ maxGuessTimes: c.passwordLock.maxGuessTimes,
345
+ hints: []
346
+ }
216
347
  };
217
348
  gameStates.set(key, s);
218
349
  return s;
@@ -229,7 +360,7 @@ const generateRankText = (players) => {
229
360
  const sortedPlayers = playerList.sort((a, b) => b.score - a.score);
230
361
  let rankText = '🏆 排行榜 🏆\n';
231
362
  sortedPlayers.forEach((player, index) => {
232
- rankText += `${index + 1}. ${player.name}（${player.platform}-${player.userId}） - 得分：${player.score}分（答对${player.correctCount}题）\n`;
363
+ rankText += `${index + 1}. ${player.name} - 得分：${player.score}分（答对${player.correctCount}题）\n`;
233
364
  });
234
365
  return rankText.trim();
235
366
  };
@@ -238,6 +369,7 @@ const clearGameData = (gameState) => {
238
369
  gameState.participants = [];
239
370
  gameState.currentRound = 0;
240
371
  gameState.started = false;
372
+ clearGameTimer(gameState);
241
373
  };
242
374
  const addScoreToOthers = (players, excludePlayerKey) => {
243
375
  Object.keys(players).forEach(playerKey => {
@@ -246,10 +378,79 @@ const addScoreToOthers = (players, excludePlayerKey) => {
246
378
  }
247
379
  });
248
380
  };
381
+ const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
382
+ clearGameTimer(state);
383
+ if (cfg.autoStopInactiveTime <= 0)
384
+ return;
385
+ state.stopTimer = setTimeout(() => {
386
+ clearGameData(state);
387
+ session.send(endMsg);
388
+ if (showRank && session.channelId) {
389
+ session.send(generateRankText(state.players));
390
+ }
391
+ }, cfg.autoStopInactiveTime * 1000);
392
+ };
393
+ const calculate24 = (numbers) => {
394
+ if (numbers.length === 1)
395
+ return Math.abs(numbers[0] - 24) < 0.001;
396
+ for (let i = 0; i < numbers.length; i++) {
397
+ for (let j = 0; j < numbers.length; j++) {
398
+ if (i === j)
399
+ continue;
400
+ const rest = [];
401
+ for (let k = 0; k < numbers.length; k++) {
402
+ if (k !== i && k !== j)
403
+ rest.push(numbers[k]);
404
+ }
405
+ const a = numbers[i];
406
+ const b = numbers[j];
407
+ if (calculate24([...rest, a + b]))
408
+ return true;
409
+ if (calculate24([...rest, a - b]))
410
+ return true;
411
+ if (calculate24([...rest, b - a]))
412
+ return true;
413
+ if (calculate24([...rest, a * b]))
414
+ return true;
415
+ if (b !== 0 && calculate24([...rest, a / b]))
416
+ return true;
417
+ if (a !== 0 && calculate24([...rest, b / a]))
418
+ return true;
419
+ }
420
+ }
421
+ return false;
422
+ };
423
+ const generatePasswordHint = (password, guess) => {
424
+ let correctPos = 0;
425
+ let correctNum = 0;
426
+ const passwordArr = password.split('');
427
+ const guessArr = guess.split('');
428
+ const passwordUsed = [false, false, false, false];
429
+ const guessUsed = [false, false, false, false];
430
+ for (let i = 0; i < 4; i++) {
431
+ if (passwordArr[i] === guessArr[i]) {
432
+ correctPos++;
433
+ passwordUsed[i] = true;
434
+ guessUsed[i] = true;
435
+ }
436
+ }
437
+ for (let i = 0; i < 4; i++) {
438
+ if (guessUsed[i])
439
+ continue;
440
+ for (let j = 0; j < 4; j++) {
441
+ if (!passwordUsed[j] && passwordArr[j] === guessArr[i]) {
442
+ correctNum++;
443
+ passwordUsed[j] = true;
444
+ break;
445
+ }
446
+ }
447
+ }
448
+ return `提示：${correctPos}个数字位置正确，${correctNum}个数字正确但位置错误`;
449
+ };
249
450
  function apply(ctx, cfg) {
250
451
  const d = {
251
452
  guessNumber: {
252
- usage: "用法错误！正确用法：guess start/stop 或 直接输入数字",
453
+ usage: "用法错误！正确用法：猜数字 开始 | 猜数字 [数字] | 猜数字 结束",
253
454
  start: "猜数字比赛开始！本次共 {0} 回合～",
254
455
  stop: "猜数字比赛已停止",
255
456
  outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！",
@@ -261,12 +462,13 @@ function apply(ctx, cfg) {
261
462
  rankTitle: "🏆 排行榜 🏆",
262
463
  rankEmpty: "暂无参与记录～",
263
464
  disabled: "猜数字功能已关闭，请联系管理员开启",
465
+ autoStop: "游戏因长时间无人操作，已自动结束"
264
466
  },
265
467
  wzHero: {
266
468
  start: "王者英雄猜谜开始！本次共 {0} 回合～",
267
- startUsage: "用法错误！正确用法：wzhero start [难度] 开始游戏",
469
+ startUsage: "用法错误！正确用法：王者英雄 开始 [难度] | 王者英雄 [答案] | 王者英雄 提示 | 王者英雄 结束",
268
470
  stop: "王者英雄猜谜比赛已停止",
269
- notStarted: "王者英雄猜谜比赛尚未开始，请输入 wzhero start [难度] 开始游戏",
471
+ notStarted: "王者英雄猜谜比赛尚未开始，请输入 王者英雄 开始 [难度] 开始游戏",
270
472
  hint: "提示",
271
473
  apiError: "API请求失败，请稍后再试",
272
474
  correct: "答对啦！你获得1分～",
@@ -276,12 +478,13 @@ function apply(ctx, cfg) {
276
478
  rankTitle: "🏆 排行榜 🏆",
277
479
  rankEmpty: "暂无参与记录～",
278
480
  disabled: "王者英雄猜谜功能已关闭，请联系管理员开启",
481
+ autoStop: "游戏因长时间无人操作，已自动结束"
279
482
  },
280
483
  chengyuImage: {
281
484
  start: "看图猜成语比赛开始！本次共 {0} 回合～",
282
485
  stop: "看图猜成语比赛已停止",
283
- submitUsage: "请直接输入你猜测的成语，或输入 提示 获取线索",
284
- notStarted: "看图猜成语比赛尚未开始，请输入 cyimage start 开始游戏",
486
+ submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
487
+ notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
285
488
  next: "第 {0} 题来啦！",
286
489
  hintGet: "【提示】{0}",
287
490
  hintError: "获取提示失败，请稍后再试",
@@ -293,12 +496,13 @@ function apply(ctx, cfg) {
293
496
  rankTitle: "🏆 排行榜 🏆",
294
497
  rankEmpty: "暂无参与记录～",
295
498
  disabled: "看图猜成语功能已关闭，请联系管理员开启",
499
+ autoStop: "游戏因长时间无人操作，已自动结束"
296
500
  },
297
501
  chengyuJielong: {
298
502
  start: "成语接龙比赛开始！本次共 {0} 回合～我先来～",
299
503
  stop: "成语接龙比赛已停止",
300
- notStarted: "成语接龙比赛尚未开始，请输入 cyjl start 开始游戏",
301
- joinUsage: "请直接发送四字成语参与接龙",
504
+ notStarted: "成语接龙比赛尚未开始，请输入 成语接龙 开始 开始游戏",
505
+ joinUsage: "请直接发送 成语接龙 [成语] 参与接龙",
302
506
  apiError: "API请求失败，请稍后再试",
303
507
  botTurn: "该我了！我接：{0}（{1}）\n释义：{2}",
304
508
  botWin: "哈哈我接不上了！本轮结束～",
@@ -312,6 +516,68 @@ function apply(ctx, cfg) {
312
516
  rankTitle: "🏆 排行榜 🏆",
313
517
  rankEmpty: "暂无参与记录～",
314
518
  disabled: "成语接龙功能已关闭，请联系管理员开启",
519
+ autoStop: "游戏因长时间无人操作，已自动结束"
520
+ },
521
+ dice: {
522
+ start: "掷骰子比大小游戏开始！本次共 {0} 回合～",
523
+ stop: "掷骰子比大小游戏已停止",
524
+ notStarted: "掷骰子比大小游戏尚未开始，请输入 掷骰子 开始 开始游戏",
525
+ roll: "🎲 你掷出了 {0} 点！机器人掷出了 {1} 点！",
526
+ win: "你赢了这一回合！获得1分～",
527
+ lose: "机器人赢了这一回合！",
528
+ draw: "平局！双方都不得分～",
529
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
530
+ gameEnd: "🎉 掷骰子比大小游戏结束！🎉",
531
+ rankTitle: "🏆 排行榜 🏆",
532
+ rankEmpty: "暂无参与记录～",
533
+ disabled: "掷骰子比大小功能已关闭，请联系管理员开启",
534
+ autoStop: "游戏因长时间无人操作，已自动结束"
535
+ },
536
+ rps: {
537
+ start: "石头剪刀布游戏开始！本次共 {0} 回合～",
538
+ stop: "石头剪刀布游戏已停止",
539
+ notStarted: "石头剪刀布游戏尚未开始，请输入 石头剪刀布 开始 开始游戏",
540
+ choice: "你选择了 {0}，机器人选择了 {1}！",
541
+ win: "你赢了这一回合！获得1分～",
542
+ lose: "机器人赢了这一回合！",
543
+ draw: "平局！双方都不得分～",
544
+ invalidChoice: "无效的选择！请输入 石头、剪刀 或 布",
545
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
546
+ gameEnd: "🎉 石头剪刀布游戏结束！🎉",
547
+ rankTitle: "🏆 排行榜 🏆",
548
+ rankEmpty: "暂无参与记录～",
549
+ disabled: "石头剪刀布功能已关闭，请联系管理员开启",
550
+ autoStop: "游戏因长时间无人操作，已自动结束"
551
+ },
552
+ calc24: {
553
+ start: "算24点游戏开始！本次共 {0} 回合～",
554
+ stop: "算24点游戏已停止",
555
+ notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
556
+ generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
557
+ correct: "答对啦！你获得1分～",
558
+ wrong: "答错啦～这组数可以算出24哦！",
559
+ impossible: "这组数无法算出24！本轮作废～",
560
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
561
+ gameEnd: "🎉 算24点游戏结束！🎉",
562
+ rankTitle: "🏆 排行榜 🏆",
563
+ rankEmpty: "暂无参与记录～",
564
+ disabled: "算24点功能已关闭，请联系管理员开启",
565
+ autoStop: "游戏因长时间无人操作，已自动结束"
566
+ },
567
+ passwordLock: {
568
+ start: "密码锁破解游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
569
+ stop: "密码锁破解游戏已停止",
570
+ notStarted: "密码锁破解游戏尚未开始，请输入 密码锁 开始 开始游戏",
571
+ guess: "你猜测的密码是：{0}，这是第 {1} 次猜测",
572
+ correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～",
573
+ wrong: "密码错误！{0}",
574
+ noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
575
+ invalidPassword: "无效的密码！请输入4位数字",
576
+ gameEnd: "🎉 密码锁破解游戏结束！🎉",
577
+ rankTitle: "🏆 排行榜 🏆",
578
+ rankEmpty: "暂无参与记录～",
579
+ disabled: "密码锁破解功能已关闭，请联系管理员开启",
580
+ autoStop: "游戏因长时间无人操作，已自动结束"
315
581
  },
316
582
  common: {
317
583
  gameRunning: "当前已有游戏在运行中，请先结束当前游戏后再开始新游戏！",
@@ -348,20 +614,6 @@ function apply(ctx, cfg) {
348
614
  doAutoPlay(session, key, st);
349
615
  }, delay);
350
616
  };
351
- const scheduleStop = (session, key, st) => {
352
- clearTimeout(st.chengyuJielong.stopTimer);
353
- st.chengyuJielong.stopTimer = setTimeout(() => {
354
- st.chengyuJielong.started = false;
355
- clearAllTimers(st);
356
- session.send(d.common.gameStoppedByInactive);
357
- if (cfg.chengyuJielong.showRank && !isPrivate(session)) {
358
- const rankText = generateRankText(st.chengyuJielong.players);
359
- session.send(rankText);
360
- }
361
- clearGameData(st.chengyuJielong);
362
- gameStates.set(key, st);
363
- }, cfg.autoStopInactiveTime * 1000);
364
- };
365
617
  const doAutoPlay = async (session, key, st) => {
366
618
  if (!st.chengyuJielong.started)
367
619
  return;
@@ -371,7 +623,7 @@ function apply(ctx, cfg) {
371
623
  session.send(d.chengyuJielong.autoPlayTooMany.replace('{0}', String(cfg.autoPlayMaxCount)));
372
624
  st.chengyuJielong.hasTriggeredAutoPlay = true;
373
625
  gameStates.set(key, st);
374
- scheduleStop(session, key, st);
626
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
375
627
  return;
376
628
  }
377
629
  st.chengyuJielong.hasTriggeredAutoPlay = true;
@@ -422,7 +674,7 @@ function apply(ctx, cfg) {
422
674
  await session.send(d.chengyuJielong.apiError);
423
675
  }
424
676
  gameStates.set(key, st);
425
- scheduleStop(session, key, st);
677
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
426
678
  };
427
679
  ctx.middleware(async (session, next) => {
428
680
  if (!session.content)
@@ -435,11 +687,13 @@ function apply(ctx, cfg) {
435
687
  const playerKey = `${session.platform}_${session.userId || 'unknown'}`;
436
688
  if (cfg.enableChengyuJielong && st.chengyuJielong.started) {
437
689
  refreshActive(st);
690
+ clearGameTimer(st.chengyuJielong);
438
691
  if (!st.chengyuJielong.players[playerKey]) {
439
692
  st.chengyuJielong.players[playerKey] = getPlayerData(session);
440
693
  st.chengyuJielong.participants.push(playerKey);
441
694
  }
442
695
  if (!isFourCharIdiom(content)) {
696
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
443
697
  scheduleAutoPlay(session, key, st);
444
698
  return next();
445
699
  }
@@ -489,6 +743,7 @@ function apply(ctx, cfg) {
489
743
  m += '\n' + d.chengyuJielong.roundEnd.replace('{0}', st.chengyuJielong.currentRound.toString()).replace('{1}', (st.chengyuJielong.totalRounds - st.chengyuJielong.currentRound).toString());
490
744
  await session.send(m);
491
745
  st.chengyuJielong.hasTriggeredAutoPlay = false;
746
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
492
747
  scheduleAutoPlay(session, key, st);
493
748
  }
494
749
  }
@@ -501,12 +756,14 @@ function apply(ctx, cfg) {
501
756
  }
502
757
  catch (error) {
503
758
  await session.send(d.chengyuJielong.apiError);
759
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
504
760
  scheduleAutoPlay(session, key, st);
505
761
  }
506
762
  gameStates.set(key, st);
507
763
  return;
508
764
  }
509
765
  if (cfg.enableChengyuImage && st.chengyuImage.started) {
766
+ clearGameTimer(st.chengyuImage);
510
767
  if (!st.chengyuImage.players[playerKey]) {
511
768
  st.chengyuImage.players[playerKey] = getPlayerData(session);
512
769
  st.chengyuImage.participants.push(playerKey);
@@ -516,7 +773,8 @@ function apply(ctx, cfg) {
516
773
  const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
517
774
  params: {
518
775
  action: 'get_hint',
519
- id: st.chengyuImage.currentId
776
+ id: st.chengyuImage.currentId,
777
+ level: 1
520
778
  },
521
779
  timeout: cfg.apiConfig.timeout
522
780
  });
@@ -531,10 +789,13 @@ function apply(ctx, cfg) {
531
789
  catch (error) {
532
790
  await session.send(d.chengyuImage.hintError);
533
791
  }
792
+ setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
534
793
  return;
535
794
  }
536
- if (!isFourCharIdiom(content))
795
+ if (!isFourCharIdiom(content)) {
796
+ setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
537
797
  return next();
798
+ }
538
799
  try {
539
800
  const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
540
801
  params: {
@@ -554,6 +815,7 @@ function apply(ctx, cfg) {
554
815
  st.chengyuImage.currentRound += 1;
555
816
  if (st.chengyuImage.currentRound > st.chengyuImage.totalRounds) {
556
817
  st.chengyuImage.started = false;
818
+ clearGameTimer(st.chengyuImage);
557
819
  await session.send(reply);
558
820
  await session.send(d.chengyuImage.gameEnd);
559
821
  if (cfg.chengyuImage.showRank && !isPrivate(session)) {
@@ -577,7 +839,7 @@ function apply(ctx, cfg) {
577
839
  st.chengyuImage.currentId = nextDt.data.question.id;
578
840
  st.chengyuImage.currentPage = nextDt.data.question.page;
579
841
  st.chengyuImage.options = nextDt.data.question.options;
580
- st.chengyuImage.answer = nextDt.data.question.answer;
842
+ st.chengyuImage.answer = nextDt.data.question.answer || '';
581
843
  await session.send(d.chengyuImage.next.replace('{0}', st.chengyuImage.currentRound.toString()));
582
844
  await session.send(`请从选项中选择4个字组成成语\n选项：${nextDt.data.question.options.join('、')}`);
583
845
  await session.send(koishi_1.segment.image(nextDt.data.question.image_url));
@@ -585,6 +847,7 @@ function apply(ctx, cfg) {
585
847
  else {
586
848
  await session.send('获取下一题失败，比赛结束！');
587
849
  st.chengyuImage.started = false;
850
+ clearGameTimer(st.chengyuImage);
588
851
  if (cfg.chengyuImage.showRank && !isPrivate(session)) {
589
852
  const rankText = generateRankText(st.chengyuImage.players);
590
853
  await session.send(rankText);
@@ -594,7 +857,8 @@ function apply(ctx, cfg) {
594
857
  }
595
858
  }
596
859
  else {
597
- reply = d.chengyuImage.wrong.replace('{0}', st.chengyuImage.answer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
860
+ const correctAnswer = dt.data?.correct_answer || st.chengyuImage.answer;
861
+ reply = d.chengyuImage.wrong.replace('{0}', correctAnswer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
598
862
  await session.send(reply);
599
863
  }
600
864
  }
@@ -605,10 +869,12 @@ function apply(ctx, cfg) {
605
869
  catch (error) {
606
870
  await session.send(d.chengyuImage.apiError);
607
871
  }
872
+ setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
608
873
  gameStates.set(key, st);
609
874
  return;
610
875
  }
611
876
  if (cfg.enableWzHero && st.wzHero.started) {
877
+ clearGameTimer(st.wzHero);
612
878
  if (!st.wzHero.players[playerKey]) {
613
879
  st.wzHero.players[playerKey] = getPlayerData(session);
614
880
  st.wzHero.participants.push(playerKey);
@@ -628,6 +894,7 @@ function apply(ctx, cfg) {
628
894
  st.wzHero.currentRound += 1;
629
895
  if (st.wzHero.currentRound > st.wzHero.totalRounds) {
630
896
  st.wzHero.started = false;
897
+ clearGameTimer(st.wzHero);
631
898
  await session.send(text);
632
899
  await session.send(d.wzHero.gameEnd);
633
900
  if (cfg.wzHero.showRank && !isPrivate(session)) {
@@ -664,23 +931,28 @@ function apply(ctx, cfg) {
664
931
  catch (error) {
665
932
  await session.send(d.wzHero.apiError);
666
933
  }
934
+ setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
667
935
  gameStates.set(key, st);
668
936
  return;
669
937
  }
670
938
  if (cfg.enableNumberGuess && st.guessNumber.started) {
939
+ clearGameTimer(st.guessNumber);
671
940
  if (!st.guessNumber.players[playerKey]) {
672
941
  st.guessNumber.players[playerKey] = getPlayerData(session);
673
942
  st.guessNumber.participants.push(playerKey);
674
943
  }
675
944
  const num = parseInt(content);
676
- if (isNaN(num))
945
+ if (isNaN(num)) {
946
+ setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
677
947
  return next();
948
+ }
678
949
  if (num === st.guessNumber.target) {
679
950
  await session.send(d.guessNumber.correct);
680
951
  addScoreToOthers(st.guessNumber.players, playerKey);
681
952
  st.guessNumber.currentRound += 1;
682
953
  if (st.guessNumber.currentRound > st.guessNumber.totalRounds) {
683
954
  st.guessNumber.started = false;
955
+ clearGameTimer(st.guessNumber);
684
956
  await session.send(d.guessNumber.gameEnd);
685
957
  if (cfg.guessNumber.showRank && !isPrivate(session)) {
686
958
  const rankText = generateRankText(st.guessNumber.players);
@@ -695,243 +967,483 @@ function apply(ctx, cfg) {
695
967
  }
696
968
  }
697
969
  else if (num < st.guessNumber.target) {
698
- await session.send(d.guessNumber.tooSmall.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
970
+ st.guessNumber.currentMin = num + 1;
971
+ await session.send(d.guessNumber.tooSmall.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
699
972
  }
700
973
  else {
701
- await session.send(d.guessNumber.tooBig.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMin.toString()));
974
+ st.guessNumber.currentMax = num - 1;
975
+ await session.send(d.guessNumber.tooBig.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
702
976
  }
977
+ setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
703
978
  gameStates.set(key, st);
704
979
  return;
705
980
  }
706
- return next();
707
- });
708
- if (cfg.enableWzHero) {
709
- ctx.command('wzhero <action:string> [difficulty:string]')
710
- .action(async (argv, action, difficulty) => {
711
- const s = argv.session;
712
- if (!s)
713
- return '';
714
- const key = getSessionKey(s);
715
- const st = gameStates.get(key) || initState(key, cfg);
716
- if (action === 'start') {
717
- if (checkGameRunning(st, 'wzHero')) {
718
- s.send(d.common.gameRunning);
719
- return '';
720
- }
721
- const fd = difficulty || '中等';
722
- if (!['简单', '中等', '困难'].includes(fd)) {
723
- await s.send(d.wzHero.startUsage);
724
- return '';
725
- }
726
- st.wzHero.started = true;
727
- st.wzHero.difficulty = fd;
728
- st.wzHero.totalRounds = cfg.wzHero.totalRounds;
729
- st.wzHero.currentRound = 1;
730
- st.wzHero.players = {};
731
- st.wzHero.participants = [];
732
- gameStates.set(key, st);
733
- try {
734
- const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
735
- params: { id: getIntUserId(s), msg: `开始游戏${fd}` }, timeout: cfg.apiConfig.timeout
736
- });
737
- const dt = r.data;
738
- if (dt.status === 'success') {
739
- let t = `${dt.message}\n${dt.hint}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide}`;
740
- t = t.replace(/\\n/g, '\n');
741
- t = d.wzHero.start.replace('{0}', cfg.wzHero.totalRounds.toString()) + '\n' + t;
742
- st.wzHero.currentAnswer = dt.hint || '';
743
- await s.send(t);
744
- }
745
- else {
746
- await s.send(dt.message || '开始失败');
747
- }
981
+ if (cfg.enableDice && st.dice.started) {
982
+ clearGameTimer(st.dice);
983
+ if (!st.dice.players[playerKey]) {
984
+ st.dice.players[playerKey] = getPlayerData(session);
985
+ st.dice.participants.push(playerKey);
986
+ }
987
+ if (content !== '掷骰子') {
988
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
989
+ return next();
990
+ }
991
+ st.dice.playerDice = koishi_1.Random.int(1, 6);
992
+ st.dice.botDice = cfg.dice.botParticipate ? koishi_1.Random.int(1, 6) : 0;
993
+ let resultMsg = d.dice.roll.replace('{0}', st.dice.playerDice.toString()).replace('{1}', st.dice.botDice.toString());
994
+ if (cfg.dice.botParticipate) {
995
+ if (st.dice.playerDice > st.dice.botDice) {
996
+ resultMsg += '\n' + d.dice.win;
997
+ st.dice.players[playerKey].score += 1;
998
+ st.dice.players[playerKey].correctCount += 1;
748
999
  }
749
- catch (error) {
750
- await s.send(d.wzHero.apiError);
751
- st.wzHero.started = false;
1000
+ else if (st.dice.playerDice < st.dice.botDice) {
1001
+ resultMsg += '\n' + d.dice.lose;
752
1002
  }
1003
+ else {
1004
+ resultMsg += '\n' + d.dice.draw;
1005
+ }
1006
+ }
1007
+ else {
1008
+ resultMsg += '\n你掷出了 ' + st.dice.playerDice + ' 点！';
1009
+ st.dice.players[playerKey].score += 1;
753
1010
  }
754
- else if (action === 'stop') {
755
- st.wzHero.started = false;
756
- await s.send(d.wzHero.stop);
757
- if (cfg.wzHero.showRank && !isPrivate(s)) {
758
- const rankText = generateRankText(st.wzHero.players);
759
- await s.send(rankText);
1011
+ await session.send(resultMsg);
1012
+ st.dice.currentRound += 1;
1013
+ if (st.dice.currentRound > st.dice.totalRounds) {
1014
+ st.dice.started = false;
1015
+ clearGameTimer(st.dice);
1016
+ await session.send(d.dice.gameEnd);
1017
+ if (cfg.dice.showRank && !isPrivate(session)) {
1018
+ const rankText = generateRankText(st.dice.players);
1019
+ await session.send(rankText);
760
1020
  }
761
- clearGameData(st.wzHero);
762
- gameStates.set(key, st);
1021
+ clearGameData(st.dice);
763
1022
  }
764
1023
  else {
765
- await s.send(d.wzHero.startUsage);
1024
+ await session.send(d.dice.roundEnd.replace('{0}', st.dice.currentRound.toString()).replace('{1}', (st.dice.totalRounds - st.dice.currentRound).toString()));
766
1025
  }
767
- return '';
768
- });
769
- }
770
- if (cfg.enableChengyuImage) {
771
- ctx.command('cyimage <action:string>')
772
- .action(async (argv, action) => {
773
- const s = argv.session;
774
- if (!s)
775
- return '';
776
- const key = getSessionKey(s);
777
- const st = gameStates.get(key) || initState(key, cfg);
778
- if (action === 'start') {
779
- if (checkGameRunning(st, 'chengyuImage')) {
780
- s.send(d.common.gameRunning);
781
- return '';
782
- }
783
- st.chengyuImage.started = true;
784
- st.chengyuImage.totalRounds = cfg.chengyuImage.totalRounds;
785
- st.chengyuImage.currentRound = 1;
786
- st.chengyuImage.players = {};
787
- st.chengyuImage.participants = [];
788
- try {
789
- const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
790
- params: { action: 'get_question' }, timeout: cfg.apiConfig.timeout
791
- });
792
- const dt = r.data;
793
- if (dt.success) {
794
- st.chengyuImage.currentId = dt.data.question.id;
795
- st.chengyuImage.currentPage = dt.data.question.page;
796
- st.chengyuImage.options = dt.data.question.options;
797
- st.chengyuImage.answer = dt.data.question.answer;
798
- gameStates.set(key, st);
799
- await s.send(d.chengyuImage.start.replace('{0}', cfg.chengyuImage.totalRounds.toString()));
800
- await s.send(`第 1 题来啦！\n请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
801
- await s.send(koishi_1.segment.image(dt.data.question.image_url));
802
- }
803
- else {
804
- await s.send('获取题目失败，请稍后再试');
805
- st.chengyuImage.started = false;
806
- }
1026
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
1027
+ gameStates.set(key, st);
1028
+ return;
1029
+ }
1030
+ if (cfg.enableRps && st.rps.started) {
1031
+ clearGameTimer(st.rps);
1032
+ if (!st.rps.players[playerKey]) {
1033
+ st.rps.players[playerKey] = getPlayerData(session);
1034
+ st.rps.participants.push(playerKey);
1035
+ }
1036
+ if (!st.rps.choices.includes(content)) {
1037
+ await session.send(d.rps.invalidChoice);
1038
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1039
+ return next();
1040
+ }
1041
+ st.rps.playerChoice = content;
1042
+ st.rps.botChoice = cfg.rps.botParticipate ? st.rps.choices[koishi_1.Random.int(0, 2)] : '';
1043
+ let resultMsg = d.rps.choice.replace('{0}', st.rps.playerChoice).replace('{1}', st.rps.botChoice);
1044
+ if (cfg.rps.botParticipate) {
1045
+ if ((st.rps.playerChoice === '石头' && st.rps.botChoice === '剪刀') ||
1046
+ (st.rps.playerChoice === '剪刀' && st.rps.botChoice === '布') ||
1047
+ (st.rps.playerChoice === '布' && st.rps.botChoice === '石头')) {
1048
+ resultMsg += '\n' + d.rps.win;
1049
+ st.rps.players[playerKey].score += 1;
1050
+ st.rps.players[playerKey].correctCount += 1;
807
1051
  }
808
- catch (error) {
809
- await s.send(d.chengyuImage.apiError);
810
- st.chengyuImage.started = false;
1052
+ else if (st.rps.playerChoice === st.rps.botChoice) {
1053
+ resultMsg += '\n' + d.rps.draw;
811
1054
  }
1055
+ else {
1056
+ resultMsg += '\n' + d.rps.lose;
1057
+ }
1058
+ }
1059
+ else {
1060
+ resultMsg += '\n你选择了 ' + st.rps.playerChoice + '！';
1061
+ st.rps.players[playerKey].score += 1;
812
1062
  }
813
- else if (action === 'stop') {
814
- st.chengyuImage.started = false;
815
- await s.send(d.chengyuImage.stop);
816
- if (cfg.chengyuImage.showRank && !isPrivate(s)) {
817
- const rankText = generateRankText(st.chengyuImage.players);
818
- await s.send(rankText);
1063
+ await session.send(resultMsg);
1064
+ st.rps.currentRound += 1;
1065
+ if (st.rps.currentRound > st.rps.totalRounds) {
1066
+ st.rps.started = false;
1067
+ clearGameTimer(st.rps);
1068
+ await session.send(d.rps.gameEnd);
1069
+ if (cfg.rps.showRank && !isPrivate(session)) {
1070
+ const rankText = generateRankText(st.rps.players);
1071
+ await session.send(rankText);
819
1072
  }
820
- clearGameData(st.chengyuImage);
821
- gameStates.set(key, st);
1073
+ clearGameData(st.rps);
822
1074
  }
823
1075
  else {
824
- await s.send(d.chengyuImage.notStarted);
1076
+ await session.send(d.rps.roundEnd.replace('{0}', st.rps.currentRound.toString()).replace('{1}', (st.rps.totalRounds - st.rps.currentRound).toString()));
825
1077
  }
826
- return '';
827
- });
828
- }
829
- if (cfg.enableChengyuJielong) {
830
- ctx.command('cyjl <action:string>')
831
- .action(async (argv, a) => {
832
- const s = argv.session;
833
- if (!s)
834
- return '';
835
- if (isPrivate(s) && !cfg.enablePrivateGame)
836
- return '';
837
- const key = getSessionKey(s);
838
- const st = gameStates.get(key) || initState(key, cfg);
839
- if (a === 'start') {
840
- if (checkGameRunning(st, 'chengyuJielong')) {
841
- s.send(d.common.gameRunning);
842
- return '';
843
- }
844
- st.chengyuJielong.started = true;
845
- st.chengyuJielong.totalRounds = cfg.chengyuJielong.totalRounds;
846
- st.chengyuJielong.currentRound = 1;
847
- st.chengyuJielong.botTurn = true;
848
- st.chengyuJielong.autoPlayCount = 0;
849
- st.chengyuJielong.hasTriggeredAutoPlay = false;
850
- st.chengyuJielong.players = {};
851
- st.chengyuJielong.participants = [];
852
- refreshActive(st);
853
- gameStates.set(key, st);
1078
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1079
+ gameStates.set(key, st);
1080
+ return;
1081
+ }
1082
+ if (cfg.enableCalc24 && st.calc24.started) {
1083
+ clearGameTimer(st.calc24);
1084
+ if (!st.calc24.players[playerKey]) {
1085
+ st.calc24.players[playerKey] = getPlayerData(session);
1086
+ st.calc24.participants.push(playerKey);
1087
+ }
1088
+ if (content === '换题') {
1089
+ st.calc24.numbers = [];
1090
+ for (let i = 0; i < 4; i++) {
1091
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1092
+ }
1093
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
1094
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1095
+ return next();
1096
+ }
1097
+ st.calc24.playerAnswer = content;
1098
+ const canCalculate = calculate24([...st.calc24.numbers]);
1099
+ if (!canCalculate) {
1100
+ await session.send(d.calc24.impossible);
1101
+ }
1102
+ else {
854
1103
  try {
855
- const intUserId = getIntUserId(s);
856
- const r = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
857
- params: {
858
- id: intUserId,
859
- msg: '开始成语接龙'
860
- },
861
- timeout: cfg.apiConfig.timeout,
862
- headers: {
863
- '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'
864
- }
865
- });
866
- const dt = r.data;
867
- let m = d.chengyuJielong.start.replace('{0}', cfg.chengyuJielong.totalRounds.toString());
868
- if (dt.code === 200 && dt.data?.system) {
869
- const sys = dt.data.system;
870
- m += `\n我的第一个成语：${sys.idiom}（${sys.pinyin}）\n释义：${sys.meaning}`;
871
- st.chengyuJielong.lastChar = dt.data.current_char || '';
1104
+ const result = eval(content.replace(/[^\d\+\-\*\/\(\)\.]/g, ''));
1105
+ if (Math.abs(result - 24) < 0.001) {
1106
+ await session.send(d.calc24.correct);
1107
+ st.calc24.players[playerKey].score += 1;
1108
+ st.calc24.players[playerKey].correctCount += 1;
1109
+ }
1110
+ else {
1111
+ await session.send(d.calc24.wrong);
872
1112
  }
873
- await s.send(m);
874
1113
  }
875
- catch (error) {
876
- await s.send(d.chengyuJielong.apiError);
1114
+ catch {
1115
+ await session.send(d.calc24.wrong);
877
1116
  }
878
- gameStates.set(key, st);
879
- scheduleAutoPlay(s, key, st);
880
1117
  }
881
- else if (a === 'stop') {
882
- st.chengyuJielong.started = false;
883
- clearAllTimers(st);
884
- await s.send(d.chengyuJielong.stop);
885
- if (cfg.chengyuJielong.showRank && !isPrivate(s)) {
886
- const rankText = generateRankText(st.chengyuJielong.players);
887
- await s.send(rankText);
1118
+ st.calc24.currentRound += 1;
1119
+ if (st.calc24.currentRound > st.calc24.totalRounds) {
1120
+ st.calc24.started = false;
1121
+ clearGameTimer(st.calc24);
1122
+ await session.send(d.calc24.gameEnd);
1123
+ if (cfg.calc24.showRank && !isPrivate(session)) {
1124
+ const rankText = generateRankText(st.calc24.players);
1125
+ await session.send(rankText);
888
1126
  }
889
- clearGameData(st.chengyuJielong);
890
- gameStates.set(key, st);
1127
+ clearGameData(st.calc24);
891
1128
  }
892
1129
  else {
893
- await s.send(d.chengyuJielong.notStarted);
1130
+ st.calc24.numbers = [];
1131
+ for (let i = 0; i < 4; i++) {
1132
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1133
+ }
1134
+ await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
1135
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
894
1136
  }
895
- return '';
896
- });
897
- }
898
- if (cfg.enableNumberGuess) {
899
- ctx.command('guess <action:string>')
900
- .action(async (argv, action) => {
901
- const s = argv.session;
902
- if (!s)
903
- return '';
904
- const key = getSessionKey(s);
905
- const st = gameStates.get(key) || initState(key, cfg);
906
- if (action === 'start') {
907
- if (checkGameRunning(st, 'guessNumber')) {
908
- s.send(d.common.gameRunning);
909
- return '';
910
- }
911
- st.guessNumber.started = true;
912
- st.guessNumber.totalRounds = cfg.guessNumber.totalRounds;
913
- st.guessNumber.currentRound = 1;
914
- st.guessNumber.target = koishi_1.Random.int(st.guessNumber.currentMin, st.guessNumber.currentMax);
915
- st.guessNumber.players = {};
916
- st.guessNumber.participants = [];
917
- gameStates.set(key, st);
918
- await s.send(d.guessNumber.start.replace('{0}', cfg.guessNumber.totalRounds.toString()));
919
- await s.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}，开始你的猜测吧！`);
920
- }
921
- else if (action === 'stop') {
922
- st.guessNumber.started = false;
923
- await s.send(d.guessNumber.stop);
924
- if (cfg.guessNumber.showRank && !isPrivate(s)) {
925
- const rankText = generateRankText(st.guessNumber.players);
926
- await s.send(rankText);
927
- }
928
- clearGameData(st.guessNumber);
929
- gameStates.set(key, st);
1137
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1138
+ gameStates.set(key, st);
1139
+ return;
1140
+ }
1141
+ if (cfg.enablePasswordLock && st.passwordLock.started) {
1142
+ clearGameTimer(st.passwordLock);
1143
+ if (!st.passwordLock.players[playerKey]) {
1144
+ st.passwordLock.players[playerKey] = getPlayerData(session);
1145
+ st.passwordLock.participants.push(playerKey);
1146
+ }
1147
+ if (!/^\d{4}$/.test(content)) {
1148
+ await session.send(d.passwordLock.invalidPassword);
1149
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1150
+ return next();
1151
+ }
1152
+ st.passwordLock.playerGuess = content;
1153
+ st.passwordLock.guessTimes += 1;
1154
+ await session.send(d.passwordLock.guess.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
1155
+ if (content === st.passwordLock.password) {
1156
+ await session.send(d.passwordLock.correct.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
1157
+ st.passwordLock.players[playerKey].score += 10 - (st.passwordLock.guessTimes - 1);
1158
+ st.passwordLock.players[playerKey].correctCount += 1;
1159
+ st.passwordLock.started = false;
1160
+ clearGameTimer(st.passwordLock);
1161
+ await session.send(d.passwordLock.gameEnd);
1162
+ if (cfg.passwordLock.showRank && !isPrivate(session)) {
1163
+ const rankText = generateRankText(st.passwordLock.players);
1164
+ await session.send(rankText);
1165
+ }
1166
+ clearGameData(st.passwordLock);
930
1167
  }
931
1168
  else {
932
- await s.send(d.guessNumber.usage);
1169
+ let hint = '';
1170
+ if (cfg.passwordLock.showHint) {
1171
+ hint = generatePasswordHint(st.passwordLock.password, content);
1172
+ }
1173
+ if (st.passwordLock.guessTimes >= st.passwordLock.maxGuessTimes) {
1174
+ await session.send(d.passwordLock.noChance.replace('{0}', st.passwordLock.password));
1175
+ st.passwordLock.started = false;
1176
+ clearGameTimer(st.passwordLock);
1177
+ await session.send(d.passwordLock.gameEnd);
1178
+ if (cfg.passwordLock.showRank && !isPrivate(session)) {
1179
+ const rankText = generateRankText(st.passwordLock.players);
1180
+ await session.send(rankText);
1181
+ }
1182
+ clearGameData(st.passwordLock);
1183
+ }
1184
+ else {
1185
+ await session.send(d.passwordLock.wrong.replace('{0}', hint));
1186
+ await session.send(`剩余猜测次数：${st.passwordLock.maxGuessTimes - st.passwordLock.guessTimes}`);
1187
+ }
933
1188
  }
934
- return '';
935
- });
936
- }
1189
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1190
+ gameStates.set(key, st);
1191
+ return;
1192
+ }
1193
+ return next();
1194
+ });
1195
+ ctx.command('猜数字 <action> [param]', '猜数字游戏')
1196
+ .action(async (argv, action, param) => {
1197
+ const session = argv.session;
1198
+ if (!session)
1199
+ return;
1200
+ const key = getSessionKey(session);
1201
+ const st = gameStates.get(key) || initState(key, cfg);
1202
+ if (checkGameRunning(st)) {
1203
+ await session.send(d.common.gameRunning);
1204
+ return;
1205
+ }
1206
+ if (action === '开始') {
1207
+ st.guessNumber.started = true;
1208
+ st.guessNumber.target = koishi_1.Random.int(cfg.guessNumber.min, cfg.guessNumber.max);
1209
+ st.guessNumber.currentMin = cfg.guessNumber.min;
1210
+ st.guessNumber.currentMax = cfg.guessNumber.max;
1211
+ st.guessNumber.currentRound = 1;
1212
+ await session.send(d.guessNumber.start.replace('{0}', st.guessNumber.totalRounds.toString()));
1213
+ await session.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}`);
1214
+ gameStates.set(key, st);
1215
+ setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
1216
+ }
1217
+ else if (action === '结束') {
1218
+ clearGameData(st.guessNumber);
1219
+ await session.send(d.guessNumber.stop);
1220
+ gameStates.set(key, st);
1221
+ }
1222
+ else {
1223
+ await session.send(d.guessNumber.usage);
1224
+ }
1225
+ });
1226
+ ctx.command('王者英雄 <action> [param]', '王者英雄猜谜')
1227
+ .action(async (argv, action, param) => {
1228
+ const session = argv.session;
1229
+ if (!session)
1230
+ return;
1231
+ const key = getSessionKey(session);
1232
+ const st = gameStates.get(key) || initState(key, cfg);
1233
+ if (checkGameRunning(st)) {
1234
+ await session.send(d.common.gameRunning);
1235
+ return;
1236
+ }
1237
+ if (action === '开始') {
1238
+ st.wzHero.started = true;
1239
+ st.wzHero.difficulty = param || '简单';
1240
+ st.wzHero.currentRound = 1;
1241
+ try {
1242
+ const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
1243
+ params: { id: getIntUserId(session), msg: `开始游戏${st.wzHero.difficulty}` },
1244
+ timeout: cfg.apiConfig.timeout
1245
+ });
1246
+ const dt = r.data;
1247
+ let text = `${dt.message || ''}\n${dt.hint || ''}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide || ''}`;
1248
+ text = text.replace(/\\n/g, '\n');
1249
+ await session.send(d.wzHero.start.replace('{0}', st.wzHero.totalRounds.toString()));
1250
+ await session.send(text);
1251
+ st.wzHero.currentAnswer = dt.hint || '';
1252
+ }
1253
+ catch (e) {
1254
+ await session.send(d.wzHero.apiError);
1255
+ }
1256
+ gameStates.set(key, st);
1257
+ setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
1258
+ }
1259
+ else if (action === '结束') {
1260
+ clearGameData(st.wzHero);
1261
+ await session.send(d.wzHero.stop);
1262
+ gameStates.set(key, st);
1263
+ }
1264
+ else {
1265
+ await session.send(d.wzHero.startUsage);
1266
+ }
1267
+ });
1268
+ ctx.command('看图猜成语 <action>', '看图猜成语')
1269
+ .action(async (argv, action) => {
1270
+ const session = argv.session;
1271
+ if (!session)
1272
+ return;
1273
+ const key = getSessionKey(session);
1274
+ const st = gameStates.get(key) || initState(key, cfg);
1275
+ if (checkGameRunning(st)) {
1276
+ await session.send(d.common.gameRunning);
1277
+ return;
1278
+ }
1279
+ if (action === '开始') {
1280
+ st.chengyuImage.started = true;
1281
+ st.chengyuImage.currentRound = 1;
1282
+ try {
1283
+ const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
1284
+ params: { action: 'next_question', page: 1 },
1285
+ timeout: cfg.apiConfig.timeout
1286
+ });
1287
+ const dt = r.data;
1288
+ if (dt.success) {
1289
+ st.chengyuImage.currentId = dt.data.question.id;
1290
+ st.chengyuImage.currentPage = dt.data.question.page;
1291
+ st.chengyuImage.options = dt.data.question.options;
1292
+ st.chengyuImage.answer = dt.data.question.answer || '';
1293
+ await session.send(d.chengyuImage.start.replace('{0}', st.chengyuImage.totalRounds.toString()));
1294
+ await session.send(`请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
1295
+ await session.send(koishi_1.segment.image(dt.data.question.image_url));
1296
+ }
1297
+ else {
1298
+ await session.send(d.chengyuImage.apiError);
1299
+ }
1300
+ }
1301
+ catch (e) {
1302
+ await session.send(d.chengyuImage.apiError);
1303
+ }
1304
+ gameStates.set(key, st);
1305
+ setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
1306
+ }
1307
+ else if (action === '结束') {
1308
+ clearGameData(st.chengyuImage);
1309
+ await session.send(d.chengyuImage.stop);
1310
+ gameStates.set(key, st);
1311
+ }
1312
+ else {
1313
+ await session.send(d.chengyuImage.submitUsage);
1314
+ }
1315
+ });
1316
+ ctx.command('成语接龙 <action>', '成语接龙')
1317
+ .action(async (argv, action) => {
1318
+ const session = argv.session;
1319
+ if (!session)
1320
+ return;
1321
+ const key = getSessionKey(session);
1322
+ const st = gameStates.get(key) || initState(key, cfg);
1323
+ if (checkGameRunning(st)) {
1324
+ await session.send(d.common.gameRunning);
1325
+ return;
1326
+ }
1327
+ if (action === '开始') {
1328
+ st.chengyuJielong.started = true;
1329
+ st.chengyuJielong.currentRound = 1;
1330
+ st.chengyuJielong.hasTriggeredAutoPlay = false;
1331
+ st.chengyuJielong.autoPlayCount = 0;
1332
+ await session.send(d.chengyuJielong.start.replace('{0}', st.chengyuJielong.totalRounds.toString()));
1333
+ gameStates.set(key, st);
1334
+ scheduleAutoPlay(session, key, st);
1335
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
1336
+ }
1337
+ else if (action === '结束') {
1338
+ clearGameData(st.chengyuJielong);
1339
+ await session.send(d.chengyuJielong.stop);
1340
+ gameStates.set(key, st);
1341
+ }
1342
+ else {
1343
+ await session.send(d.chengyuJielong.joinUsage);
1344
+ }
1345
+ });
1346
+ ctx.command('掷骰子 <action>', '掷骰子比大小')
1347
+ .action(async (argv, action) => {
1348
+ const session = argv.session;
1349
+ if (!session)
1350
+ return;
1351
+ const key = getSessionKey(session);
1352
+ const st = gameStates.get(key) || initState(key, cfg);
1353
+ if (checkGameRunning(st)) {
1354
+ await session.send(d.common.gameRunning);
1355
+ return;
1356
+ }
1357
+ if (action === '开始') {
1358
+ st.dice.started = true;
1359
+ st.dice.currentRound = 1;
1360
+ await session.send(d.dice.start.replace('{0}', st.dice.totalRounds.toString()));
1361
+ gameStates.set(key, st);
1362
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
1363
+ }
1364
+ else if (action === '结束') {
1365
+ clearGameData(st.dice);
1366
+ await session.send(d.dice.stop);
1367
+ gameStates.set(key, st);
1368
+ }
1369
+ });
1370
+ ctx.command('石头剪刀布 <action>', '石头剪刀布')
1371
+ .action(async (argv, action) => {
1372
+ const session = argv.session;
1373
+ if (!session)
1374
+ return;
1375
+ const key = getSessionKey(session);
1376
+ const st = gameStates.get(key) || initState(key, cfg);
1377
+ if (checkGameRunning(st)) {
1378
+ await session.send(d.common.gameRunning);
1379
+ return;
1380
+ }
1381
+ if (action === '开始') {
1382
+ st.rps.started = true;
1383
+ st.rps.currentRound = 1;
1384
+ await session.send(d.rps.start.replace('{0}', st.rps.totalRounds.toString()));
1385
+ gameStates.set(key, st);
1386
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1387
+ }
1388
+ else if (action === '结束') {
1389
+ clearGameData(st.rps);
1390
+ await session.send(d.rps.stop);
1391
+ gameStates.set(key, st);
1392
+ }
1393
+ });
1394
+ ctx.command('算24点 <action>', '算24点游戏')
1395
+ .action(async (argv, action) => {
1396
+ const session = argv.session;
1397
+ if (!session)
1398
+ return;
1399
+ const key = getSessionKey(session);
1400
+ const st = gameStates.get(key) || initState(key, cfg);
1401
+ if (checkGameRunning(st)) {
1402
+ await session.send(d.common.gameRunning);
1403
+ return;
1404
+ }
1405
+ if (action === '开始') {
1406
+ st.calc24.started = true;
1407
+ st.calc24.currentRound = 1;
1408
+ st.calc24.numbers = [];
1409
+ for (let i = 0; i < 4; i++) {
1410
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1411
+ }
1412
+ await session.send(d.calc24.start.replace('{0}', st.calc24.totalRounds.toString()));
1413
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
1414
+ gameStates.set(key, st);
1415
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1416
+ }
1417
+ else if (action === '结束') {
1418
+ clearGameData(st.calc24);
1419
+ await session.send(d.calc24.stop);
1420
+ gameStates.set(key, st);
1421
+ }
1422
+ });
1423
+ ctx.command('密码锁 <action>', '密码锁破解')
1424
+ .action(async (argv, action) => {
1425
+ const session = argv.session;
1426
+ if (!session)
1427
+ return;
1428
+ const key = getSessionKey(session);
1429
+ const st = gameStates.get(key) || initState(key, cfg);
1430
+ if (checkGameRunning(st)) {
1431
+ await session.send(d.common.gameRunning);
1432
+ return;
1433
+ }
1434
+ if (action === '开始') {
1435
+ st.passwordLock.started = true;
1436
+ st.passwordLock.currentRound = 1;
1437
+ st.passwordLock.guessTimes = 0;
1438
+ st.passwordLock.password = koishi_1.Random.int(1000, 9999).toString();
1439
+ await session.send(d.passwordLock.start.replace('{0}', st.passwordLock.maxGuessTimes.toString()));
1440
+ gameStates.set(key, st);
1441
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1442
+ }
1443
+ else if (action === '结束') {
1444
+ clearGameData(st.passwordLock);
1445
+ await session.send(d.passwordLock.stop);
1446
+ gameStates.set(key, st);
1447
+ }
1448
+ });
937
1449
  }