koishi-plugin-game-mini 0.2.2 → 0.2.4

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 -0
  2. package/lib/index.js +843 -277
  3. package/lib/locales/locales/zh-CN.yml +78 -42
  4. package/package.json +14 -5
package/lib/index.js CHANGED
@@ -15,109 +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
72
  totalRounds: koishi_1.Schema.number().min(1).default(10)
61
73
  .description('王者英雄猜谜总回合数')
62
- .i18n({ 'zh-CN': '总回合数' }),
74
+ .i18n({ 'zh-CN': '王者英雄猜谜总回合数' }),
63
75
  showRank: koishi_1.Schema.boolean().default(true)
64
- .description('游戏结束后是否显示排行榜')
65
- .i18n({ 'zh-CN': '显示排行榜' }),
76
+ .description('王者英雄猜谜显示排行榜')
77
+ .i18n({ 'zh-CN': '王者英雄猜谜显示排行榜' }),
66
78
  }).description('王者英雄猜谜游戏配置')
67
- .i18n({ 'zh-CN': '王者英雄猜谜配置' }),
79
+ .i18n({ 'zh-CN': '王者英雄猜谜游戏配置' }),
68
80
  chengyuImage: koishi_1.Schema.object({
69
81
  totalRounds: koishi_1.Schema.number().min(1).default(10)
70
82
  .description('看图猜成语总回合数')
71
- .i18n({ 'zh-CN': '总回合数' }),
83
+ .i18n({ 'zh-CN': '看图猜成语总回合数' }),
72
84
  showRank: koishi_1.Schema.boolean().default(true)
73
- .description('游戏结束后是否显示排行榜')
74
- .i18n({ 'zh-CN': '显示排行榜' }),
85
+ .description('看图猜成语显示排行榜')
86
+ .i18n({ 'zh-CN': '看图猜成语显示排行榜' }),
75
87
  }).description('看图猜成语游戏配置')
76
- .i18n({ 'zh-CN': '看图猜成语配置' }),
88
+ .i18n({ 'zh-CN': '看图猜成语游戏配置' }),
77
89
  chengyuJielong: koishi_1.Schema.object({
78
90
  botParticipateInGroup: koishi_1.Schema.boolean().default(true)
79
- .description('群聊中机器人是否参与成语接龙')
80
- .i18n({ 'zh-CN': '机器人参与群聊游戏' }),
91
+ .description('群聊中机器人参与成语接龙')
92
+ .i18n({ 'zh-CN': '群聊中机器人参与成语接龙' }),
81
93
  totalRounds: koishi_1.Schema.number().min(1).default(10)
82
94
  .description('成语接龙总回合数')
83
- .i18n({ 'zh-CN': '总回合数' }),
95
+ .i18n({ 'zh-CN': '成语接龙总回合数' }),
84
96
  showRank: koishi_1.Schema.boolean().default(true)
85
- .description('游戏结束后是否显示排行榜')
86
- .i18n({ 'zh-CN': '显示排行榜' }),
97
+ .description('成语接龙显示排行榜')
98
+ .i18n({ 'zh-CN': '成语接龙显示排行榜' }),
87
99
  }).description('成语接龙游戏配置')
88
- .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': '密码锁破解游戏配置' }),
89
149
  apiConfig: koishi_1.Schema.object({
90
150
  timeout: koishi_1.Schema.number().default(5000)
91
151
  .description('API请求超时时间（毫秒）')
92
- .i18n({ 'zh-CN': '请求超时时间(毫秒)' }),
152
+ .i18n({ 'zh-CN': 'API请求超时时间（毫秒）' }),
93
153
  }).description('API接口配置')
94
154
  .i18n({ 'zh-CN': 'API接口配置' }),
95
155
  }).i18n({
96
156
  'zh-CN': {
97
157
  'enableNumberGuess': '启用猜数字游戏',
98
- 'enableWzHero': '启用王者英雄猜谜',
99
- 'enableChengyuImage': '启用看图猜成语',
100
- 'enableChengyuJielong': '启用成语接龙',
158
+ 'enableWzHero': '启用王者英雄猜谜游戏',
159
+ 'enableChengyuImage': '启用看图猜成语游戏',
160
+ 'enableChengyuJielong': '启用成语接龙游戏',
161
+ 'enableDice': '启用掷骰子比大小游戏',
162
+ 'enableRps': '启用石头剪刀布游戏',
163
+ 'enableCalc24': '启用算24点游戏',
164
+ 'enablePasswordLock': '启用猜密码游戏',
101
165
  'enablePrivateGame': '允许私聊玩游戏',
102
- 'autoPlayDelay': '机器人自动接龙延迟(秒)',
103
- 'autoPlayMaxCount': '机器人最大自动接龙次数',
104
- 'autoStopInactiveTime': '无操作自动停止时间(秒)',
166
+ 'autoPlayDelay': '机器人自动操作延迟（秒）',
167
+ 'autoPlayMaxCount': '机器人最大自动操作次数',
168
+ 'autoStopInactiveTime': '游戏无操作自动停止时间（秒）',
105
169
  'guessNumber': '猜数字游戏配置',
106
- 'guessNumber.min': '最小值',
107
- 'guessNumber.max': '最大值',
108
- 'guessNumber.botParticipateInGroup': '机器人参与群聊游戏',
109
- 'guessNumber.totalRounds': '总回合数',
110
- 'guessNumber.showRank': '显示排行榜',
111
- 'wzHero': '王者英雄猜谜配置',
112
- 'wzHero.totalRounds': '总回合数',
113
- 'wzHero.showRank': '显示排行榜',
170
+ 'guessNumber.min': '猜数字最小值',
171
+ 'guessNumber.max': '猜数字最大值',
172
+ 'guessNumber.botParticipateInGroup': '群聊中机器人参与猜数字',
173
+ 'guessNumber.totalRounds': '猜数字总回合数',
174
+ 'guessNumber.showRank': '猜数字显示排行榜',
175
+ 'wzHero': '猜王者英雄配置',
176
+ 'wzHero.totalRounds': '猜王者英雄总回合数',
177
+ 'wzHero.showRank': '猜王者英雄显示排行榜',
114
178
  'chengyuImage': '看图猜成语配置',
115
- 'chengyuImage.totalRounds': '总回合数',
116
- 'chengyuImage.showRank': '显示排行榜',
179
+ 'chengyuImage.totalRounds': '看图猜成语总回合数',
180
+ 'chengyuImage.showRank': '看图猜成语显示排行榜',
117
181
  'chengyuJielong': '成语接龙配置',
118
- 'chengyuJielong.botParticipateInGroup': '机器人参与群聊游戏',
119
- 'chengyuJielong.totalRounds': '总回合数',
120
- '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': '猜密码显示排行榜',
121
201
  'apiConfig': 'API接口配置',
122
202
  'apiConfig.timeout': '请求超时时间(毫秒)'
123
203
  }
@@ -149,6 +229,14 @@ const checkGameRunning = (s, t) => {
149
229
  return true;
150
230
  if (t !== 'chengyuJielong' && s.chengyuJielong.started)
151
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;
152
240
  return false;
153
241
  };
154
242
  const clearGameTimer = (state) => {
@@ -160,6 +248,10 @@ const clearAllTimers = (st) => {
160
248
  clearGameTimer(st.wzHero);
161
249
  clearGameTimer(st.chengyuImage);
162
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
257
  };
@@ -209,8 +301,51 @@ const initState = (key, c) => {
209
301
  botTurn: true,
210
302
  autoPlayCount: 0,
211
303
  hasTriggeredAutoPlay: false,
212
- 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
315
+ },
316
+ rps: {
317
+ started: false,
318
+ totalRounds: c.rps.totalRounds,
319
+ currentRound: 0,
320
+ players: {},
321
+ participants: [],
322
+ playerChoice: '',
323
+ botChoice: '',
324
+ choices: ['石头', '剪刀', '布']
213
325
  },
326
+ calc24: {
327
+ started: false,
328
+ totalRounds: c.calc24.totalRounds,
329
+ currentRound: 0,
330
+ players: {},
331
+ participants: [],
332
+ numbers: [],
333
+ playerAnswer: '',
334
+ solved: false
335
+ },
336
+ passwordLock: {
337
+ started: false,
338
+ totalRounds: 1,
339
+ currentRound: 0,
340
+ players: {},
341
+ participants: [],
342
+ password: '',
343
+ playerGuess: '',
344
+ guessTimes: 0,
345
+ maxGuessTimes: c.passwordLock.maxGuessTimes,
346
+ hints: [],
347
+ solved: false
348
+ }
214
349
  };
215
350
  gameStates.set(key, s);
216
351
  return s;
@@ -257,10 +392,67 @@ const setupAutoStop = (session, state, cfg, endMsg, showRank) => {
257
392
  }
258
393
  }, cfg.autoStopInactiveTime * 1000);
259
394
  };
395
+ const calculate24 = (numbers) => {
396
+ if (numbers.length === 1)
397
+ return Math.abs(numbers[0] - 24) < 0.001;
398
+ for (let i = 0; i < numbers.length; i++) {
399
+ for (let j = 0; j < numbers.length; j++) {
400
+ if (i === j)
401
+ continue;
402
+ const rest = [];
403
+ for (let k = 0; k < numbers.length; k++) {
404
+ if (k !== i && k !== j)
405
+ rest.push(numbers[k]);
406
+ }
407
+ const a = numbers[i];
408
+ const b = numbers[j];
409
+ if (calculate24([...rest, a + b]))
410
+ return true;
411
+ if (calculate24([...rest, a - b]))
412
+ return true;
413
+ if (calculate24([...rest, b - a]))
414
+ return true;
415
+ if (calculate24([...rest, a * b]))
416
+ return true;
417
+ if (b !== 0 && calculate24([...rest, a / b]))
418
+ return true;
419
+ if (a !== 0 && calculate24([...rest, b / a]))
420
+ return true;
421
+ }
422
+ }
423
+ return false;
424
+ };
425
+ const generatePasswordHint = (password, guess) => {
426
+ let correctPos = 0;
427
+ let correctNum = 0;
428
+ const passwordArr = password.split('');
429
+ const guessArr = guess.split('');
430
+ const passwordUsed = [false, false, false, false];
431
+ const guessUsed = [false, false, false, false];
432
+ for (let i = 0; i < 4; i++) {
433
+ if (passwordArr[i] === guessArr[i]) {
434
+ correctPos++;
435
+ passwordUsed[i] = true;
436
+ guessUsed[i] = true;
437
+ }
438
+ }
439
+ for (let i = 0; i < 4; i++) {
440
+ if (guessUsed[i])
441
+ continue;
442
+ for (let j = 0; j < 4; j++) {
443
+ if (!passwordUsed[j] && passwordArr[j] === guessArr[i]) {
444
+ correctNum++;
445
+ passwordUsed[j] = true;
446
+ break;
447
+ }
448
+ }
449
+ }
450
+ return `提示：${correctPos}个数字位置正确，${correctNum}个数字正确但位置错误`;
451
+ };
260
452
  function apply(ctx, cfg) {
261
453
  const d = {
262
454
  guessNumber: {
263
- usage: "用法错误！正确用法：guess start/stop 或 直接输入数字",
455
+ usage: "用法错误！正确用法：猜数字 开始 | 猜数字 [数字] | 猜数字 结束",
264
456
  start: "猜数字比赛开始！本次共 {0} 回合～",
265
457
  stop: "猜数字比赛已停止",
266
458
  outOfRange: "数字超出当前范围 [{0}-{1}]，请重新输入！",
@@ -275,26 +467,26 @@ function apply(ctx, cfg) {
275
467
  autoStop: "游戏因长时间无人操作，已自动结束"
276
468
  },
277
469
  wzHero: {
278
- start: "王者英雄猜谜开始！本次共 {0} 回合～",
279
- startUsage: "用法错误！正确用法：wzhero start [难度] 开始游戏",
280
- stop: "王者英雄猜谜比赛已停止",
281
- notStarted: "王者英雄猜谜比赛尚未开始，请输入 wzhero start [难度] 开始游戏",
470
+ start: "猜王者英雄开始！本次共 {0} 回合～",
471
+ startUsage: "用法错误！正确用法：猜王者英雄 开始 [难度] | 猜王者英雄 [答案] | 猜王者英雄 提示 | 猜王者英雄 结束",
472
+ stop: "猜王者英雄比赛已停止",
473
+ notStarted: "猜王者英雄比赛尚未开始，请输入 猜王者英雄 开始 [难度] 开始游戏",
282
474
  hint: "提示",
283
475
  apiError: "API请求失败，请稍后再试",
284
476
  correct: "答对啦！你获得1分～",
285
477
  wrong: "答错啦～正确答案是：{0}，你不得分",
286
478
  roundEnd: "第 {0} 回合结束！剩余回合：{1}",
287
- gameEnd: "🎉 王者英雄猜谜比赛结束！🎉",
479
+ gameEnd: "🎉 猜王者英雄比赛结束！🎉",
288
480
  rankTitle: "🏆 排行榜 🏆",
289
481
  rankEmpty: "暂无参与记录～",
290
- disabled: "王者英雄猜谜功能已关闭，请联系管理员开启",
482
+ disabled: "猜王者英雄功能已关闭，请联系管理员开启",
291
483
  autoStop: "游戏因长时间无人操作，已自动结束"
292
484
  },
293
485
  chengyuImage: {
294
486
  start: "看图猜成语比赛开始！本次共 {0} 回合～",
295
487
  stop: "看图猜成语比赛已停止",
296
- submitUsage: "请直接输入你猜测的成语，或输入 提示 获取线索",
297
- notStarted: "看图猜成语比赛尚未开始，请输入 cyimage start 开始游戏",
488
+ submitUsage: "请直接输入 看图猜成语 [答案]，或输入 看图猜成语 提示 获取线索",
489
+ notStarted: "看图猜成语比赛尚未开始，请输入 看图猜成语 开始 开始游戏",
298
490
  next: "第 {0} 题来啦！",
299
491
  hintGet: "【提示】{0}",
300
492
  hintError: "获取提示失败，请稍后再试",
@@ -311,8 +503,8 @@ function apply(ctx, cfg) {
311
503
  chengyuJielong: {
312
504
  start: "成语接龙比赛开始！本次共 {0} 回合～我先来～",
313
505
  stop: "成语接龙比赛已停止",
314
- notStarted: "成语接龙比赛尚未开始，请输入 cyjl start 开始游戏",
315
- joinUsage: "请直接发送四字成语参与接龙",
506
+ notStarted: "成语接龙比赛尚未开始，请输入 成语接龙 开始 开始游戏",
507
+ joinUsage: "请直接发送 成语接龙 [成语] 参与接龙",
316
508
  apiError: "API请求失败，请稍后再试",
317
509
  botTurn: "该我了！我接：{0}（{1}）\n释义：{2}",
318
510
  botWin: "哈哈我接不上了！本轮结束～",
@@ -328,6 +520,69 @@ function apply(ctx, cfg) {
328
520
  disabled: "成语接龙功能已关闭，请联系管理员开启",
329
521
  autoStop: "游戏因长时间无人操作，已自动结束"
330
522
  },
523
+ dice: {
524
+ start: "掷骰子比大小游戏开始！本次共 {0} 回合～",
525
+ stop: "掷骰子比大小游戏已停止",
526
+ notStarted: "掷骰子比大小游戏尚未开始，请输入 掷骰子 开始 开始游戏",
527
+ roll: "🎲 你掷出了 {0} 点！机器人掷出了 {1} 点！",
528
+ win: "你赢了这一回合！获得1分～",
529
+ lose: "机器人赢了这一回合！",
530
+ draw: "平局！双方都不得分～",
531
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
532
+ gameEnd: "🎉 掷骰子比大小游戏结束！🎉",
533
+ rankTitle: "🏆 排行榜 🏆",
534
+ rankEmpty: "暂无参与记录～",
535
+ disabled: "掷骰子比大小功能已关闭，请联系管理员开启",
536
+ autoStop: "游戏因长时间无人操作，已自动结束"
537
+ },
538
+ rps: {
539
+ start: "石头剪刀布游戏开始！本次共 {0} 回合～",
540
+ stop: "石头剪刀布游戏已停止",
541
+ notStarted: "石头剪刀布游戏尚未开始，请输入 石头剪刀布 开始 开始游戏",
542
+ choice: "你选择了 {0}，机器人选择了 {1}！",
543
+ win: "你赢了这一回合！获得1分～",
544
+ lose: "机器人赢了这一回合！",
545
+ draw: "平局！双方都不得分～",
546
+ invalidChoice: "无效的选择！请输入 石头、剪刀 或 布",
547
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
548
+ gameEnd: "🎉 石头剪刀布游戏结束！🎉",
549
+ rankTitle: "🏆 排行榜 🏆",
550
+ rankEmpty: "暂无参与记录～",
551
+ disabled: "石头剪刀布功能已关闭，请联系管理员开启",
552
+ autoStop: "游戏因长时间无人操作，已自动结束"
553
+ },
554
+ calc24: {
555
+ start: "算24点游戏开始！本次共 {0} 回合～",
556
+ stop: "算24点游戏已停止",
557
+ notStarted: "算24点游戏尚未开始，请输入 算24点 开始 开始游戏",
558
+ generate: "📝 第 {0} 题：用 {1} 通过加减乘除算出24！",
559
+ correct: "答对啦！你获得1分～",
560
+ wrong: "答错啦～",
561
+ impossible: "这组数无法算出24！本题作废，换一组数字～",
562
+ solved: "这组数已经被答对啦，换一组数字～",
563
+ roundEnd: "第 {0} 回合结束！剩余回合：{1}",
564
+ gameEnd: "🎉 算24点游戏结束！🎉",
565
+ rankTitle: "🏆 排行榜 🏆",
566
+ rankEmpty: "暂无参与记录～",
567
+ disabled: "算24点功能已关闭，请联系管理员开启",
568
+ autoStop: "游戏因长时间无人操作，已自动结束"
569
+ },
570
+ passwordLock: {
571
+ start: "猜密码游戏开始！密码为4位数字，你有 {0} 次猜测机会～",
572
+ stop: "猜密码游戏已停止",
573
+ notStarted: "猜密码游戏尚未开始，请输入 猜密码 开始 开始游戏",
574
+ guess: "你猜测的密码是：{0}，这是第 {1} 次猜测",
575
+ correct: "🎉 恭喜！你猜对了密码 {0}！总共猜测了 {1} 次，获得10分～",
576
+ wrong: "密码错误！{0}",
577
+ solved: "密码已经被猜出来啦，游戏结束～",
578
+ noChance: "❌ 没有猜测机会了！正确密码是：{0}～",
579
+ invalidPassword: "无效的密码！请输入4位数字",
580
+ gameEnd: "🎉 猜密码游戏结束！🎉",
581
+ rankTitle: "🏆 排行榜 🏆",
582
+ rankEmpty: "暂无参与记录～",
583
+ disabled: "猜密码功能已关闭，请联系管理员开启",
584
+ autoStop: "游戏因长时间无人操作，已自动结束"
585
+ },
331
586
  common: {
332
587
  gameRunning: "当前已有游戏在运行中，请先结束当前游戏后再开始新游戏！",
333
588
  gameStoppedByInactive: "游戏因长时间无人操作，已自动结束",
@@ -522,7 +777,8 @@ function apply(ctx, cfg) {
522
777
  const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
523
778
  params: {
524
779
  action: 'get_hint',
525
- id: st.chengyuImage.currentId
780
+ id: st.chengyuImage.currentId,
781
+ level: 1
526
782
  },
527
783
  timeout: cfg.apiConfig.timeout
528
784
  });
@@ -587,7 +843,7 @@ function apply(ctx, cfg) {
587
843
  st.chengyuImage.currentId = nextDt.data.question.id;
588
844
  st.chengyuImage.currentPage = nextDt.data.question.page;
589
845
  st.chengyuImage.options = nextDt.data.question.options;
590
- st.chengyuImage.answer = nextDt.data.question.answer;
846
+ st.chengyuImage.answer = nextDt.data.question.answer || '';
591
847
  await session.send(d.chengyuImage.next.replace('{0}', st.chengyuImage.currentRound.toString()));
592
848
  await session.send(`请从选项中选择4个字组成成语\n选项：${nextDt.data.question.options.join('、')}`);
593
849
  await session.send(koishi_1.segment.image(nextDt.data.question.image_url));
@@ -605,7 +861,8 @@ function apply(ctx, cfg) {
605
861
  }
606
862
  }
607
863
  else {
608
- reply = d.chengyuImage.wrong.replace('{0}', st.chengyuImage.answer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
864
+ const correctAnswer = dt.data?.correct_answer || st.chengyuImage.answer;
865
+ reply = d.chengyuImage.wrong.replace('{0}', correctAnswer).replace('{1}', st.chengyuImage.players[playerKey].score.toString());
609
866
  await session.send(reply);
610
867
  }
611
868
  }
@@ -626,6 +883,12 @@ function apply(ctx, cfg) {
626
883
  st.wzHero.players[playerKey] = getPlayerData(session);
627
884
  st.wzHero.participants.push(playerKey);
628
885
  }
886
+ if (content === '结束') {
887
+ clearGameData(st.wzHero);
888
+ await session.send(d.wzHero.stop);
889
+ gameStates.set(key, st);
890
+ return;
891
+ }
629
892
  try {
630
893
  const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
631
894
  params: { id: getIntUserId(session), msg: content }, timeout: cfg.apiConfig.timeout
@@ -688,6 +951,12 @@ function apply(ctx, cfg) {
688
951
  st.guessNumber.players[playerKey] = getPlayerData(session);
689
952
  st.guessNumber.participants.push(playerKey);
690
953
  }
954
+ if (content === '结束') {
955
+ clearGameData(st.guessNumber);
956
+ await session.send(d.guessNumber.stop);
957
+ gameStates.set(key, st);
958
+ return;
959
+ }
691
960
  const num = parseInt(content);
692
961
  if (isNaN(num)) {
693
962
  setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
@@ -714,251 +983,548 @@ function apply(ctx, cfg) {
714
983
  }
715
984
  }
716
985
  else if (num < st.guessNumber.target) {
717
- await session.send(d.guessNumber.tooSmall.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
986
+ st.guessNumber.currentMin = num + 1;
987
+ await session.send(d.guessNumber.tooSmall.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
718
988
  }
719
989
  else {
720
- await session.send(d.guessNumber.tooBig.replace('{0}', num.toString()).replace('{1}', st.guessNumber.currentMin.toString()));
990
+ st.guessNumber.currentMax = num - 1;
991
+ await session.send(d.guessNumber.tooBig.replace('{0}', st.guessNumber.currentMin.toString()).replace('{1}', st.guessNumber.currentMax.toString()));
721
992
  }
722
993
  setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
723
994
  gameStates.set(key, st);
724
995
  return;
725
996
  }
726
- return next();
727
- });
728
- if (cfg.enableWzHero) {
729
- ctx.command('wzhero <action:string> [difficulty:string]')
730
- .action(async (argv, action, difficulty) => {
731
- const s = argv.session;
732
- if (!s)
733
- return '';
734
- const key = getSessionKey(s);
735
- const st = gameStates.get(key) || initState(key, cfg);
736
- if (action === 'start') {
737
- if (checkGameRunning(st, 'wzHero')) {
738
- s.send(d.common.gameRunning);
739
- return '';
997
+ if (cfg.enableDice && st.dice.started) {
998
+ clearGameTimer(st.dice);
999
+ if (!st.dice.players[playerKey]) {
1000
+ st.dice.players[playerKey] = getPlayerData(session);
1001
+ st.dice.participants.push(playerKey);
1002
+ }
1003
+ if (content === '结束') {
1004
+ clearGameData(st.dice);
1005
+ await session.send(d.dice.stop);
1006
+ gameStates.set(key, st);
1007
+ return;
1008
+ }
1009
+ if (content !== '掷骰子') {
1010
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
1011
+ return next();
1012
+ }
1013
+ st.dice.playerDice = koishi_1.Random.int(1, 6);
1014
+ st.dice.botDice = koishi_1.Random.int(1, 6);
1015
+ let resultMsg = d.dice.roll.replace('{0}', st.dice.playerDice.toString()).replace('{1}', st.dice.botDice.toString());
1016
+ if (st.dice.playerDice > st.dice.botDice) {
1017
+ resultMsg += '\n' + d.dice.win;
1018
+ st.dice.players[playerKey].score += 1;
1019
+ st.dice.players[playerKey].correctCount += 1;
1020
+ }
1021
+ else if (st.dice.playerDice < st.dice.botDice) {
1022
+ resultMsg += '\n' + d.dice.lose;
1023
+ }
1024
+ else {
1025
+ resultMsg += '\n' + d.dice.draw;
1026
+ }
1027
+ await session.send(resultMsg);
1028
+ st.dice.currentRound += 1;
1029
+ if (st.dice.currentRound > st.dice.totalRounds) {
1030
+ st.dice.started = false;
1031
+ clearGameTimer(st.dice);
1032
+ await session.send(d.dice.gameEnd);
1033
+ if (cfg.dice.showRank && !isPrivate(session)) {
1034
+ const rankText = generateRankText(st.dice.players);
1035
+ await session.send(rankText);
740
1036
  }
741
- const fd = difficulty || '中等';
742
- if (!['简单', '中等', '困难'].includes(fd)) {
743
- await s.send(d.wzHero.startUsage);
744
- return '';
1037
+ clearGameData(st.dice);
1038
+ }
1039
+ else {
1040
+ await session.send(d.dice.roundEnd.replace('{0}', st.dice.currentRound.toString()).replace('{1}', (st.dice.totalRounds - st.dice.currentRound).toString()));
1041
+ }
1042
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
1043
+ gameStates.set(key, st);
1044
+ return;
1045
+ }
1046
+ if (cfg.enableRps && st.rps.started) {
1047
+ clearGameTimer(st.rps);
1048
+ if (!st.rps.players[playerKey]) {
1049
+ st.rps.players[playerKey] = getPlayerData(session);
1050
+ st.rps.participants.push(playerKey);
1051
+ }
1052
+ if (content === '结束') {
1053
+ clearGameData(st.rps);
1054
+ await session.send(d.rps.stop);
1055
+ gameStates.set(key, st);
1056
+ return;
1057
+ }
1058
+ if (!st.rps.choices.includes(content)) {
1059
+ await session.send(d.rps.invalidChoice);
1060
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1061
+ return;
1062
+ }
1063
+ st.rps.playerChoice = content;
1064
+ st.rps.botChoice = st.rps.choices[koishi_1.Random.int(0, 2)];
1065
+ let resultMsg = d.rps.choice.replace('{0}', st.rps.playerChoice).replace('{1}', st.rps.botChoice);
1066
+ if ((st.rps.playerChoice === '石头' && st.rps.botChoice === '剪刀') ||
1067
+ (st.rps.playerChoice === '剪刀' && st.rps.botChoice === '布') ||
1068
+ (st.rps.playerChoice === '布' && st.rps.botChoice === '石头')) {
1069
+ resultMsg += '\n' + d.rps.win;
1070
+ st.rps.players[playerKey].score += 1;
1071
+ st.rps.players[playerKey].correctCount += 1;
1072
+ }
1073
+ else if (st.rps.playerChoice === st.rps.botChoice) {
1074
+ resultMsg += '\n' + d.rps.draw;
1075
+ }
1076
+ else {
1077
+ resultMsg += '\n' + d.rps.lose;
1078
+ }
1079
+ await session.send(resultMsg);
1080
+ st.rps.currentRound += 1;
1081
+ if (st.rps.currentRound > st.rps.totalRounds) {
1082
+ st.rps.started = false;
1083
+ clearGameTimer(st.rps);
1084
+ await session.send(d.rps.gameEnd);
1085
+ if (cfg.rps.showRank && !isPrivate(session)) {
1086
+ const rankText = generateRankText(st.rps.players);
1087
+ await session.send(rankText);
745
1088
  }
746
- st.wzHero.started = true;
747
- st.wzHero.difficulty = fd;
748
- st.wzHero.totalRounds = cfg.wzHero.totalRounds;
749
- st.wzHero.currentRound = 1;
750
- st.wzHero.players = {};
751
- st.wzHero.participants = [];
1089
+ clearGameData(st.rps);
1090
+ }
1091
+ else {
1092
+ await session.send(d.rps.roundEnd.replace('{0}', st.rps.currentRound.toString()).replace('{1}', (st.rps.totalRounds - st.rps.currentRound).toString()));
1093
+ }
1094
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1095
+ gameStates.set(key, st);
1096
+ return;
1097
+ }
1098
+ if (cfg.enableCalc24 && st.calc24.started) {
1099
+ clearGameTimer(st.calc24);
1100
+ if (!st.calc24.players[playerKey]) {
1101
+ st.calc24.players[playerKey] = getPlayerData(session);
1102
+ st.calc24.participants.push(playerKey);
1103
+ }
1104
+ if (content === '结束') {
1105
+ clearGameData(st.calc24);
1106
+ await session.send(d.calc24.stop);
752
1107
  gameStates.set(key, st);
753
- try {
754
- const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
755
- params: { id: getIntUserId(s), msg: `开始游戏${fd}` }, timeout: cfg.apiConfig.timeout
756
- });
757
- const dt = r.data;
758
- if (dt.status === 'success') {
759
- let t = `${dt.message}\n${dt.hint}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide}`;
760
- t = t.replace(/\\n/g, '\n');
761
- t = d.wzHero.start.replace('{0}', cfg.wzHero.totalRounds.toString()) + '\n' + t;
762
- st.wzHero.currentAnswer = dt.hint || '';
763
- await s.send(t);
764
- setupAutoStop(s, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
1108
+ return;
1109
+ }
1110
+ if (content === '换题') {
1111
+ if (!st.calc24.solved) {
1112
+ st.calc24.numbers = [];
1113
+ for (let i = 0; i < 4; i++) {
1114
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1115
+ }
1116
+ st.calc24.solved = false;
1117
+ const canCalculate = calculate24([...st.calc24.numbers]);
1118
+ if (!canCalculate) {
1119
+ await session.send(d.calc24.impossible);
765
1120
  }
766
1121
  else {
767
- await s.send(dt.message || '开始失败');
1122
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
768
1123
  }
769
1124
  }
770
- catch (error) {
771
- await s.send(d.wzHero.apiError);
772
- st.wzHero.started = false;
773
- }
1125
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1126
+ return;
774
1127
  }
775
- else if (action === 'stop') {
776
- st.wzHero.started = false;
777
- clearGameTimer(st.wzHero);
778
- await s.send(d.wzHero.stop);
779
- if (cfg.wzHero.showRank && !isPrivate(s)) {
780
- const rankText = generateRankText(st.wzHero.players);
781
- await s.send(rankText);
1128
+ if (st.calc24.solved) {
1129
+ await session.send(d.calc24.solved);
1130
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1131
+ return;
1132
+ }
1133
+ st.calc24.playerAnswer = content;
1134
+ const canCalculate = calculate24([...st.calc24.numbers]);
1135
+ if (!canCalculate) {
1136
+ await session.send(d.calc24.impossible);
1137
+ st.calc24.numbers = [];
1138
+ for (let i = 0; i < 4; i++) {
1139
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
782
1140
  }
783
- clearGameData(st.wzHero);
784
- gameStates.set(key, st);
1141
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
785
1142
  }
786
1143
  else {
787
- await s.send(d.wzHero.startUsage);
788
- }
789
- return '';
790
- });
791
- }
792
- if (cfg.enableChengyuImage) {
793
- ctx.command('cyimage <action:string>')
794
- .action(async (argv, action) => {
795
- const s = argv.session;
796
- if (!s)
797
- return '';
798
- const key = getSessionKey(s);
799
- const st = gameStates.get(key) || initState(key, cfg);
800
- if (action === 'start') {
801
- if (checkGameRunning(st, 'chengyuImage')) {
802
- s.send(d.common.gameRunning);
803
- return '';
804
- }
805
- st.chengyuImage.started = true;
806
- st.chengyuImage.totalRounds = cfg.chengyuImage.totalRounds;
807
- st.chengyuImage.currentRound = 1;
808
- st.chengyuImage.players = {};
809
- st.chengyuImage.participants = [];
810
1144
  try {
811
- const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
812
- params: { action: 'get_question' }, timeout: cfg.apiConfig.timeout
813
- });
814
- const dt = r.data;
815
- if (dt.success) {
816
- st.chengyuImage.currentId = dt.data.question.id;
817
- st.chengyuImage.currentPage = dt.data.question.page;
818
- st.chengyuImage.options = dt.data.question.options;
819
- st.chengyuImage.answer = dt.data.question.answer;
820
- gameStates.set(key, st);
821
- await s.send(d.chengyuImage.start.replace('{0}', cfg.chengyuImage.totalRounds.toString()));
822
- await s.send(`第 1 题来啦！\n请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
823
- await s.send(koishi_1.segment.image(dt.data.question.image_url));
824
- setupAutoStop(s, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
1145
+ const result = eval(content.replace(/[^\d\+\-\*\/\(\)\.]/g, ''));
1146
+ if (Math.abs(result - 24) < 0.001) {
1147
+ await session.send(d.calc24.correct);
1148
+ st.calc24.players[playerKey].score += 1;
1149
+ st.calc24.players[playerKey].correctCount += 1;
1150
+ st.calc24.solved = true;
1151
+ st.calc24.currentRound += 1;
1152
+ if (st.calc24.currentRound > st.calc24.totalRounds) {
1153
+ st.calc24.started = false;
1154
+ clearGameTimer(st.calc24);
1155
+ await session.send(d.calc24.gameEnd);
1156
+ if (cfg.calc24.showRank && !isPrivate(session)) {
1157
+ const rankText = generateRankText(st.calc24.players);
1158
+ await session.send(rankText);
1159
+ }
1160
+ clearGameData(st.calc24);
1161
+ }
1162
+ else {
1163
+ await session.send(d.calc24.roundEnd.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', (st.calc24.totalRounds - st.calc24.currentRound).toString()));
1164
+ st.calc24.numbers = [];
1165
+ for (let i = 0; i < 4; i++) {
1166
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1167
+ }
1168
+ st.calc24.solved = false;
1169
+ const nextCanCalculate = calculate24([...st.calc24.numbers]);
1170
+ if (!nextCanCalculate) {
1171
+ await session.send(d.calc24.impossible);
1172
+ }
1173
+ else {
1174
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
1175
+ }
1176
+ }
825
1177
  }
826
1178
  else {
827
- await s.send('获取题目失败，请稍后再试');
828
- st.chengyuImage.started = false;
1179
+ await session.send(d.calc24.wrong);
829
1180
  }
830
1181
  }
831
- catch (error) {
832
- await s.send(d.chengyuImage.apiError);
833
- st.chengyuImage.started = false;
1182
+ catch {
1183
+ await session.send(d.calc24.wrong);
834
1184
  }
835
1185
  }
836
- else if (action === 'stop') {
837
- st.chengyuImage.started = false;
838
- clearGameTimer(st.chengyuImage);
839
- await s.send(d.chengyuImage.stop);
840
- if (cfg.chengyuImage.showRank && !isPrivate(s)) {
841
- const rankText = generateRankText(st.chengyuImage.players);
842
- await s.send(rankText);
843
- }
844
- clearGameData(st.chengyuImage);
1186
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1187
+ gameStates.set(key, st);
1188
+ return;
1189
+ }
1190
+ if (cfg.enablePasswordLock && st.passwordLock.started) {
1191
+ clearGameTimer(st.passwordLock);
1192
+ if (!st.passwordLock.players[playerKey]) {
1193
+ st.passwordLock.players[playerKey] = getPlayerData(session);
1194
+ st.passwordLock.participants.push(playerKey);
1195
+ }
1196
+ if (content === '结束') {
1197
+ clearGameData(st.passwordLock);
1198
+ await session.send(d.passwordLock.stop);
845
1199
  gameStates.set(key, st);
1200
+ return;
846
1201
  }
847
- else {
848
- await s.send(d.chengyuImage.notStarted);
1202
+ if (st.passwordLock.solved) {
1203
+ await session.send(d.passwordLock.solved);
1204
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1205
+ return;
849
1206
  }
850
- return '';
851
- });
852
- }
853
- if (cfg.enableChengyuJielong) {
854
- ctx.command('cyjl <action:string>')
855
- .action(async (argv, a) => {
856
- const s = argv.session;
857
- if (!s)
858
- return '';
859
- if (isPrivate(s) && !cfg.enablePrivateGame)
860
- return '';
861
- const key = getSessionKey(s);
862
- const st = gameStates.get(key) || initState(key, cfg);
863
- if (a === 'start') {
864
- if (checkGameRunning(st, 'chengyuJielong')) {
865
- s.send(d.common.gameRunning);
866
- return '';
1207
+ if (!/^\d{4}$/.test(content)) {
1208
+ await session.send(d.passwordLock.invalidPassword);
1209
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1210
+ return;
1211
+ }
1212
+ st.passwordLock.playerGuess = content;
1213
+ st.passwordLock.guessTimes += 1;
1214
+ await session.send(d.passwordLock.guess.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
1215
+ if (content === st.passwordLock.password) {
1216
+ await session.send(d.passwordLock.correct.replace('{0}', content).replace('{1}', st.passwordLock.guessTimes.toString()));
1217
+ st.passwordLock.players[playerKey].score += 10 - (st.passwordLock.guessTimes - 1);
1218
+ st.passwordLock.players[playerKey].correctCount += 1;
1219
+ st.passwordLock.solved = true;
1220
+ st.passwordLock.started = false;
1221
+ clearGameTimer(st.passwordLock);
1222
+ await session.send(d.passwordLock.gameEnd);
1223
+ if (cfg.passwordLock.showRank && !isPrivate(session)) {
1224
+ const rankText = generateRankText(st.passwordLock.players);
1225
+ await session.send(rankText);
867
1226
  }
868
- st.chengyuJielong.started = true;
869
- st.chengyuJielong.totalRounds = cfg.chengyuJielong.totalRounds;
870
- st.chengyuJielong.currentRound = 1;
871
- st.chengyuJielong.botTurn = true;
872
- st.chengyuJielong.autoPlayCount = 0;
873
- st.chengyuJielong.hasTriggeredAutoPlay = false;
874
- st.chengyuJielong.players = {};
875
- st.chengyuJielong.participants = [];
876
- refreshActive(st);
877
- gameStates.set(key, st);
878
- try {
879
- const intUserId = getIntUserId(s);
880
- const r = await axios_1.default.get('https://api.suol.cc/v1/game_cyjl.php', {
881
- params: {
882
- id: intUserId,
883
- msg: '开始成语接龙'
884
- },
885
- timeout: cfg.apiConfig.timeout,
886
- headers: {
887
- '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'
888
- }
889
- });
890
- const dt = r.data;
891
- let m = d.chengyuJielong.start.replace('{0}', cfg.chengyuJielong.totalRounds.toString());
892
- if (dt.code === 200 && dt.data?.system) {
893
- const sys = dt.data.system;
894
- m += `\n我的第一个成语：${sys.idiom}（${sys.pinyin}）\n释义：${sys.meaning}`;
895
- st.chengyuJielong.lastChar = dt.data.current_char || '';
896
- }
897
- await s.send(m);
1227
+ clearGameData(st.passwordLock);
1228
+ }
1229
+ else {
1230
+ let hint = '';
1231
+ if (cfg.passwordLock.showHint) {
1232
+ hint = generatePasswordHint(st.passwordLock.password, content);
898
1233
  }
899
- catch (error) {
900
- await s.send(d.chengyuJielong.apiError);
1234
+ if (st.passwordLock.guessTimes >= st.passwordLock.maxGuessTimes) {
1235
+ await session.send(d.passwordLock.noChance.replace('{0}', st.passwordLock.password));
1236
+ st.passwordLock.started = false;
1237
+ clearGameTimer(st.passwordLock);
1238
+ await session.send(d.passwordLock.gameEnd);
1239
+ if (cfg.passwordLock.showRank && !isPrivate(session)) {
1240
+ const rankText = generateRankText(st.passwordLock.players);
1241
+ await session.send(rankText);
1242
+ }
1243
+ clearGameData(st.passwordLock);
901
1244
  }
902
- setupAutoStop(s, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
903
- gameStates.set(key, st);
904
- scheduleAutoPlay(s, key, st);
905
- }
906
- else if (a === 'stop') {
907
- st.chengyuJielong.started = false;
908
- clearAllTimers(st);
909
- await s.send(d.chengyuJielong.stop);
910
- if (cfg.chengyuJielong.showRank && !isPrivate(s)) {
911
- const rankText = generateRankText(st.chengyuJielong.players);
912
- await s.send(rankText);
1245
+ else {
1246
+ await session.send(d.passwordLock.wrong.replace('{0}', hint));
1247
+ await session.send(`剩余猜测次数：${st.passwordLock.maxGuessTimes - st.passwordLock.guessTimes}`);
913
1248
  }
914
- clearGameData(st.chengyuJielong);
915
- gameStates.set(key, st);
916
1249
  }
917
- else {
918
- await s.send(d.chengyuJielong.notStarted);
1250
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1251
+ gameStates.set(key, st);
1252
+ return;
1253
+ }
1254
+ return next();
1255
+ });
1256
+ ctx.command('猜数字 <action> [param]', '猜数字游戏')
1257
+ .action(async (argv, action, param) => {
1258
+ const session = argv.session;
1259
+ if (!session)
1260
+ return;
1261
+ const key = getSessionKey(session);
1262
+ const st = gameStates.get(key) || initState(key, cfg);
1263
+ if (checkGameRunning(st, 'guessNumber')) {
1264
+ await session.send(d.common.gameRunning);
1265
+ return;
1266
+ }
1267
+ if (action === '开始') {
1268
+ st.guessNumber.started = true;
1269
+ st.guessNumber.target = koishi_1.Random.int(cfg.guessNumber.min, cfg.guessNumber.max);
1270
+ st.guessNumber.currentMin = cfg.guessNumber.min;
1271
+ st.guessNumber.currentMax = cfg.guessNumber.max;
1272
+ st.guessNumber.currentRound = 1;
1273
+ await session.send(d.guessNumber.start.replace('{0}', st.guessNumber.totalRounds.toString()));
1274
+ await session.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}`);
1275
+ gameStates.set(key, st);
1276
+ setupAutoStop(session, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
1277
+ }
1278
+ else if (action === '结束') {
1279
+ clearGameData(st.guessNumber);
1280
+ await session.send(d.guessNumber.stop);
1281
+ gameStates.set(key, st);
1282
+ }
1283
+ else {
1284
+ await session.send(d.guessNumber.usage);
1285
+ }
1286
+ });
1287
+ ctx.command('猜王者英雄 <action> [param]', '猜王者英雄猜谜')
1288
+ .action(async (argv, action, param) => {
1289
+ const session = argv.session;
1290
+ if (!session)
1291
+ return;
1292
+ const key = getSessionKey(session);
1293
+ const st = gameStates.get(key) || initState(key, cfg);
1294
+ if (checkGameRunning(st, 'wzHero')) {
1295
+ await session.send(d.common.gameRunning);
1296
+ return;
1297
+ }
1298
+ if (action === '开始') {
1299
+ st.wzHero.started = true;
1300
+ st.wzHero.difficulty = param || '简单';
1301
+ st.wzHero.currentRound = 1;
1302
+ try {
1303
+ const r = await axios_1.default.get('https://api.suol.cc/v1/game_wz.php', {
1304
+ params: { id: getIntUserId(session), msg: `开始游戏${st.wzHero.difficulty}` },
1305
+ timeout: cfg.apiConfig.timeout
1306
+ });
1307
+ const dt = r.data;
1308
+ let text = `${dt.message || ''}\n${dt.hint || ''}\n剩余提示次数：${dt.remaining_hints}\n${dt.guide || ''}`;
1309
+ text = text.replace(/\\n/g, '\n');
1310
+ await session.send(d.wzHero.start.replace('{0}', st.wzHero.totalRounds.toString()));
1311
+ await session.send(text);
1312
+ st.wzHero.currentAnswer = dt.hint || '';
919
1313
  }
920
- return '';
921
- });
922
- }
923
- if (cfg.enableNumberGuess) {
924
- ctx.command('guess <action:string>')
925
- .action(async (argv, action) => {
926
- const s = argv.session;
927
- if (!s)
928
- return '';
929
- const key = getSessionKey(s);
930
- const st = gameStates.get(key) || initState(key, cfg);
931
- if (action === 'start') {
932
- if (checkGameRunning(st, 'guessNumber')) {
933
- s.send(d.common.gameRunning);
934
- return '';
1314
+ catch (e) {
1315
+ await session.send(d.wzHero.apiError);
1316
+ }
1317
+ gameStates.set(key, st);
1318
+ setupAutoStop(session, st.wzHero, cfg, d.wzHero.autoStop, cfg.wzHero.showRank);
1319
+ }
1320
+ else if (action === '结束') {
1321
+ clearGameData(st.wzHero);
1322
+ await session.send(d.wzHero.stop);
1323
+ gameStates.set(key, st);
1324
+ }
1325
+ else {
1326
+ await session.send(d.wzHero.startUsage);
1327
+ }
1328
+ });
1329
+ ctx.command('看图猜成语 <action>', '看图猜成语')
1330
+ .action(async (argv, action) => {
1331
+ const session = argv.session;
1332
+ if (!session)
1333
+ return;
1334
+ const key = getSessionKey(session);
1335
+ const st = gameStates.get(key) || initState(key, cfg);
1336
+ if (checkGameRunning(st, 'chengyuImage')) {
1337
+ await session.send(d.common.gameRunning);
1338
+ return;
1339
+ }
1340
+ if (action === '开始') {
1341
+ st.chengyuImage.started = true;
1342
+ st.chengyuImage.currentRound = 1;
1343
+ try {
1344
+ const r = await axios_1.default.get('https://jcy.lvlong.xyz/api/api/chengyu.php', {
1345
+ params: { action: 'next_question', page: 1 },
1346
+ timeout: cfg.apiConfig.timeout
1347
+ });
1348
+ const dt = r.data;
1349
+ if (dt.success) {
1350
+ st.chengyuImage.currentId = dt.data.question.id;
1351
+ st.chengyuImage.currentPage = dt.data.question.page;
1352
+ st.chengyuImage.options = dt.data.question.options;
1353
+ st.chengyuImage.answer = dt.data.question.answer || '';
1354
+ await session.send(d.chengyuImage.start.replace('{0}', st.chengyuImage.totalRounds.toString()));
1355
+ await session.send(`请从选项中选择4个字组成成语\n选项：${dt.data.question.options.join('、')}`);
1356
+ await session.send(koishi_1.segment.image(dt.data.question.image_url));
935
1357
  }
936
- st.guessNumber.started = true;
937
- st.guessNumber.totalRounds = cfg.guessNumber.totalRounds;
938
- st.guessNumber.currentRound = 1;
939
- st.guessNumber.target = koishi_1.Random.int(st.guessNumber.currentMin, st.guessNumber.currentMax);
940
- st.guessNumber.players = {};
941
- st.guessNumber.participants = [];
942
- gameStates.set(key, st);
943
- await s.send(d.guessNumber.start.replace('{0}', cfg.guessNumber.totalRounds.toString()));
944
- await s.send(`猜数字范围：${st.guessNumber.currentMin} - ${st.guessNumber.currentMax}，开始你的猜测吧！`);
945
- setupAutoStop(s, st.guessNumber, cfg, d.guessNumber.autoStop, cfg.guessNumber.showRank);
946
- }
947
- else if (action === 'stop') {
948
- st.guessNumber.started = false;
949
- clearGameTimer(st.guessNumber);
950
- await s.send(d.guessNumber.stop);
951
- if (cfg.guessNumber.showRank && !isPrivate(s)) {
952
- const rankText = generateRankText(st.guessNumber.players);
953
- await s.send(rankText);
1358
+ else {
1359
+ await session.send(d.chengyuImage.apiError);
954
1360
  }
955
- clearGameData(st.guessNumber);
956
- gameStates.set(key, st);
1361
+ }
1362
+ catch (e) {
1363
+ await session.send(d.chengyuImage.apiError);
1364
+ }
1365
+ gameStates.set(key, st);
1366
+ setupAutoStop(session, st.chengyuImage, cfg, d.chengyuImage.autoStop, cfg.chengyuImage.showRank);
1367
+ }
1368
+ else if (action === '结束') {
1369
+ clearGameData(st.chengyuImage);
1370
+ await session.send(d.chengyuImage.stop);
1371
+ gameStates.set(key, st);
1372
+ }
1373
+ else {
1374
+ await session.send(d.chengyuImage.submitUsage);
1375
+ }
1376
+ });
1377
+ ctx.command('成语接龙 <action>', '成语接龙')
1378
+ .action(async (argv, action) => {
1379
+ const session = argv.session;
1380
+ if (!session)
1381
+ return;
1382
+ const key = getSessionKey(session);
1383
+ const st = gameStates.get(key) || initState(key, cfg);
1384
+ if (checkGameRunning(st, 'chengyuJielong')) {
1385
+ await session.send(d.common.gameRunning);
1386
+ return;
1387
+ }
1388
+ if (action === '开始') {
1389
+ st.chengyuJielong.started = true;
1390
+ st.chengyuJielong.currentRound = 1;
1391
+ st.chengyuJielong.hasTriggeredAutoPlay = false;
1392
+ st.chengyuJielong.autoPlayCount = 0;
1393
+ await session.send(d.chengyuJielong.start.replace('{0}', st.chengyuJielong.totalRounds.toString()));
1394
+ gameStates.set(key, st);
1395
+ scheduleAutoPlay(session, key, st);
1396
+ setupAutoStop(session, st.chengyuJielong, cfg, d.chengyuJielong.autoStop, cfg.chengyuJielong.showRank);
1397
+ }
1398
+ else if (action === '结束') {
1399
+ clearGameData(st.chengyuJielong);
1400
+ await session.send(d.chengyuJielong.stop);
1401
+ gameStates.set(key, st);
1402
+ }
1403
+ else {
1404
+ await session.send(d.chengyuJielong.joinUsage);
1405
+ }
1406
+ });
1407
+ ctx.command('掷骰子 <action>', '掷骰子比大小')
1408
+ .action(async (argv, action) => {
1409
+ const session = argv.session;
1410
+ if (!session)
1411
+ return;
1412
+ const key = getSessionKey(session);
1413
+ const st = gameStates.get(key) || initState(key, cfg);
1414
+ if (checkGameRunning(st, 'dice')) {
1415
+ await session.send(d.common.gameRunning);
1416
+ return;
1417
+ }
1418
+ if (action === '开始') {
1419
+ st.dice.started = true;
1420
+ st.dice.currentRound = 1;
1421
+ await session.send(d.dice.start.replace('{0}', st.dice.totalRounds.toString()));
1422
+ gameStates.set(key, st);
1423
+ setupAutoStop(session, st.dice, cfg, d.dice.autoStop, cfg.dice.showRank);
1424
+ }
1425
+ else if (action === '结束') {
1426
+ clearGameData(st.dice);
1427
+ await session.send(d.dice.stop);
1428
+ gameStates.set(key, st);
1429
+ }
1430
+ else {
1431
+ await session.send('请输入：掷骰子 开始 或 掷骰子 结束');
1432
+ }
1433
+ });
1434
+ ctx.command('石头剪刀布 <action>', '石头剪刀布')
1435
+ .action(async (argv, action) => {
1436
+ const session = argv.session;
1437
+ if (!session)
1438
+ return;
1439
+ const key = getSessionKey(session);
1440
+ const st = gameStates.get(key) || initState(key, cfg);
1441
+ if (checkGameRunning(st, 'rps')) {
1442
+ await session.send(d.common.gameRunning);
1443
+ return;
1444
+ }
1445
+ if (action === '开始') {
1446
+ st.rps.started = true;
1447
+ st.rps.currentRound = 1;
1448
+ await session.send(d.rps.start.replace('{0}', st.rps.totalRounds.toString()));
1449
+ gameStates.set(key, st);
1450
+ setupAutoStop(session, st.rps, cfg, d.rps.autoStop, cfg.rps.showRank);
1451
+ }
1452
+ else if (action === '结束') {
1453
+ clearGameData(st.rps);
1454
+ await session.send(d.rps.stop);
1455
+ gameStates.set(key, st);
1456
+ }
1457
+ else {
1458
+ await session.send('请输入：石头剪刀布 开始 或 石头剪刀布 结束');
1459
+ }
1460
+ });
1461
+ ctx.command('算24点 <action>', '算24点游戏')
1462
+ .action(async (argv, action) => {
1463
+ const session = argv.session;
1464
+ if (!session)
1465
+ return;
1466
+ const key = getSessionKey(session);
1467
+ const st = gameStates.get(key) || initState(key, cfg);
1468
+ if (checkGameRunning(st, 'calc24')) {
1469
+ await session.send(d.common.gameRunning);
1470
+ return;
1471
+ }
1472
+ if (action === '开始') {
1473
+ st.calc24.started = true;
1474
+ st.calc24.currentRound = 1;
1475
+ st.calc24.solved = false;
1476
+ st.calc24.numbers = [];
1477
+ for (let i = 0; i < 4; i++) {
1478
+ st.calc24.numbers.push(koishi_1.Random.int(cfg.calc24.numberRange[0], cfg.calc24.numberRange[1]));
1479
+ }
1480
+ await session.send(d.calc24.start.replace('{0}', st.calc24.totalRounds.toString()));
1481
+ const canCalculate = calculate24([...st.calc24.numbers]);
1482
+ if (!canCalculate) {
1483
+ await session.send(d.calc24.impossible);
957
1484
  }
958
1485
  else {
959
- await s.send(d.guessNumber.usage);
1486
+ await session.send(d.calc24.generate.replace('{0}', st.calc24.currentRound.toString()).replace('{1}', st.calc24.numbers.join('、')));
960
1487
  }
961
- return '';
962
- });
963
- }
1488
+ gameStates.set(key, st);
1489
+ setupAutoStop(session, st.calc24, cfg, d.calc24.autoStop, cfg.calc24.showRank);
1490
+ }
1491
+ else if (action === '结束') {
1492
+ clearGameData(st.calc24);
1493
+ await session.send(d.calc24.stop);
1494
+ gameStates.set(key, st);
1495
+ }
1496
+ else {
1497
+ await session.send('请输入：算24点 开始 或 算24点 结束');
1498
+ }
1499
+ });
1500
+ ctx.command('猜密码 <action>', '猜密码游戏')
1501
+ .action(async (argv, action) => {
1502
+ const session = argv.session;
1503
+ if (!session)
1504
+ return;
1505
+ const key = getSessionKey(session);
1506
+ const st = gameStates.get(key) || initState(key, cfg);
1507
+ if (checkGameRunning(st, 'passwordLock')) {
1508
+ await session.send(d.common.gameRunning);
1509
+ return;
1510
+ }
1511
+ if (action === '开始') {
1512
+ st.passwordLock.started = true;
1513
+ st.passwordLock.currentRound = 1;
1514
+ st.passwordLock.guessTimes = 0;
1515
+ st.passwordLock.solved = false;
1516
+ st.passwordLock.password = koishi_1.Random.int(1000, 9999).toString();
1517
+ await session.send(d.passwordLock.start.replace('{0}', st.passwordLock.maxGuessTimes.toString()));
1518
+ gameStates.set(key, st);
1519
+ setupAutoStop(session, st.passwordLock, cfg, d.passwordLock.autoStop, cfg.passwordLock.showRank);
1520
+ }
1521
+ else if (action === '结束') {
1522
+ clearGameData(st.passwordLock);
1523
+ await session.send(d.passwordLock.stop);
1524
+ gameStates.set(key, st);
1525
+ }
1526
+ else {
1527
+ await session.send('请输入：猜密码 开始 或 猜密码 结束');
1528
+ }
1529
+ });
964
1530
  }