koishi-plugin-ai-puzzle 0.0.13 → 0.0.15

package/lib/game.d.ts

@@ -59,5 +59,26 @@ export declare class GameOrchestrator {
     /** 尝试用 OneBot 合并转发发送结果，成功返回 true，失败返回 false */
     private sendForwardOrFallback;
     private getHistory;
+    private pvpStates;
+    /** 创建或开始 PVP 竞技 */
+    pvp(session: Session, puzzleCount?: number): Promise<string>;
+    /** 玩家加入竞技 */
+    joinPvp(session: Session): string;
+    /** 检查用户是否在 PVP 竞技中 */
+    isInPvp(channelId: string, userId: string): boolean;
+    /** 处理 PVP 猜测 */
+    pvpProcessGuess(session: Session, guessText: string): Promise<string | null>;
+    /** 完成谜题生成，若有失败则进入 retry 状态询问组织者 */
+    private finishPvpGeneration;
+    /** 处理组织者的重试响应（在 retry 状态下） */
+    handlePvpRetry(channelId: string, userId: string, text: string): Promise<string | null>;
+    private generatePvpPuzzles;
+    private startPvpGame;
+    private pvpThrowClue;
+    private pvpScheduleClue;
+    private pvpCheckAllGuessed;
+    private pvpPenalize;
+    private pvpNextPuzzle;
+    private pvpEnd;
     private updateHistory;
 }

package/lib/index.js

@@ -36,7 +36,7 @@ var require_package = __commonJS({
     module2.exports = {
       name: "koishi-plugin-ai-puzzle",
       description: "使用AI生成猜谜谜题，支持多模式游戏、模糊匹配、图片渲染",
-      version: "0.0.13",
+      version: "0.0.15",
       main: "lib/index.js",
       typings: "lib/index.d.ts",
       files: [
@@ -80,7 +80,7 @@ var require_package = __commonJS({
 // src/locales/zh-CN.yml
 var require_zh_CN = __commonJS({
   "src/locales/zh-CN.yml"(exports2, module2) {
-    module2.exports = { commands: { "ai-puzzle": { description: "AI猜谜游戏", usage: "子命令：\nstart    触发猜谜\nswitch   切换提示词模板\nmanual   切换手动模式\nauto     切换自动模式\nopen     切换开放模式\nrestrict 切换限制模式\nnext     获取下一条线索\nguess    提交猜测\nstop     结束游戏\npre      切换预生成模式\nlist     列出提示词模板\nadd      添加用户出题\ndel      删除用户出题" }, "ai-puzzle.start": { description: "触发AI猜谜游戏", options: { extension: "额外规则参数", userPuzzle: "用户出题代号" } }, "ai-puzzle.switch": { description: "切换提示词模板", arguments: { keyword: "模板关键词" } }, "ai-puzzle.manual": { description: "切换手动模式", arguments: { interval: "最少时间间隔（秒）" } }, "ai-puzzle.auto": { description: "切换自动模式", arguments: { interval: "自动时间间隔（秒）", extraDelay: "额外延迟（秒）" } }, "ai-puzzle.open": { description: "切换开放模式" }, "ai-puzzle.restrict": { description: "切换限制模式", arguments: { perPuzzle: "每个谜题可猜测次数", perClue: "每条线索可猜测次数" } }, "ai-puzzle.next": { description: "获取下一条线索" }, "ai-puzzle.guess": { description: "提交猜测", arguments: { answer: "猜测的答案" } }, "ai-puzzle.stop": { description: "结束游戏" }, "ai-puzzle.pre": { description: "切换预生成模式" }, "ai-puzzle.list": { description: "列出提示词模板" }, "ai-puzzle.add": { description: "添加用户出题", arguments: { code: "谜题代号" } }, "ai-puzzle.del": { description: "删除用户出题", arguments: { code: "谜题代号" } } } };
+    module2.exports = { commands: { "ai-puzzle": { description: "AI猜谜游戏", usage: "子命令：\nstart    触发猜谜\nswitch   切换提示词模板\nmanual   切换手动模式\nauto     切换自动模式\nopen     切换开放模式\nrestrict 切换限制模式\nnext     获取下一条线索\nguess    提交猜测\nstop     结束游戏\npre      切换预生成模式\nlist     列出提示词模板\nadd      添加用户出题\ndel      删除用户出题" }, "ai-puzzle.start": { description: "触发AI猜谜游戏", options: { extension: "额外规则参数", userPuzzle: "用户出题代号" } }, "ai-puzzle.switch": { description: "切换提示词模板", arguments: { keyword: "模板关键词" } }, "ai-puzzle.manual": { description: "切换手动模式", arguments: { interval: "最少时间间隔（秒）" } }, "ai-puzzle.auto": { description: "切换自动模式", arguments: { interval: "自动时间间隔（秒）", extraDelay: "额外延迟（秒）" } }, "ai-puzzle.open": { description: "切换开放模式" }, "ai-puzzle.restrict": { description: "切换限制模式", arguments: { perPuzzle: "每个谜题可猜测次数", perClue: "每条线索可猜测次数" } }, "ai-puzzle.next": { description: "获取下一条线索" }, "ai-puzzle.guess": { description: "提交猜测", arguments: { answer: "猜测的答案" } }, "ai-puzzle.stop": { description: "结束游戏" }, "ai-puzzle.pre": { description: "切换预生成模式" }, "ai-puzzle.list": { description: "列出提示词模板" }, "ai-puzzle.add": { description: "添加用户出题", arguments: { code: "谜题代号" } }, "ai-puzzle.del": { description: "删除用户出题", arguments: { code: "谜题代号" } }, "ai-puzzle.pvp": { description: "PVP竞技模式", arguments: { count: "谜题数量（1-20，默认10）" } }, "ai-puzzle.join": { description: "加入PVP竞技" } } };
   }
 });
 
@@ -444,7 +444,7 @@ var PromptManager = class {
       name: parsed["名字"],
       enName: parsed["副名字"] || "",
       aliases: Array.isArray(parsed["别名"]) ? parsed["别名"].filter(Boolean) : [],
-      description: parsed["游戏介绍"] || "",
+      description: parsed["介绍"] || "",
       clues: clues.map((c) => String(c)),
       explanations: Array.isArray(parsed["线索解释"]) ? parsed["线索解释"].map((e) => String(e || "")) : clues.map(() => "")
     };
@@ -715,6 +715,10 @@ var GameOrchestrator = class {
   async startGame(session, extensionRule, userPuzzleCode) {
     const channelId = session.channelId;
     this.logger.debug("[Game] startGame: channel=%s, hasExtension=%s, userPuzzle=%s", channelId, !!extensionRule, userPuzzleCode || "(无)");
+    const pvpState = this.pvpStates.get(channelId);
+    if (pvpState && pvpState.status !== "ended") {
+      return "当前有竞技进行中，无法开始普通游戏。";
+    }
     if (!this.stateManager.isIdle(channelId)) {
       return "当前已有谜题在进行中，请先结束当前谜题。";
     }
@@ -780,6 +784,10 @@ var GameOrchestrator = class {
   /** 处理猜测（开放模式中间件 / 限制模式 guess 命令） */
   async processGuess(session, guessText) {
     const channelId = session.channelId;
+    const retryResult = await this.handlePvpRetry(channelId, session.userId, guessText);
+    if (retryResult !== null) return retryResult;
+    const pvpResult = await this.pvpProcessGuess(session, guessText);
+    if (pvpResult !== null) return pvpResult;
     const state = await this.stateManager.get(channelId);
     if (state.status !== "playing") return null;
     if (!state.openMode) {
@@ -1509,6 +1517,290 @@ var GameOrchestrator = class {
     if (!rows.length) return null;
     return { guessedItems: rows.map((r) => r.item) };
   }
+  // ========== PVP 竞技模式 ==========
+  pvpStates = /* @__PURE__ */ new Map();
+  /** 创建或开始 PVP 竞技 */
+  async pvp(session, puzzleCount) {
+    const channelId = session.channelId;
+    const pvp = this.pvpStates.get(channelId);
+    if (pvp?.status === "ready" && session.userId === pvp.organizerId) {
+      return this.startPvpGame(channelId);
+    }
+    if (!this.stateManager.isIdle(channelId)) {
+      return "当前有普通游戏进行中，无法开启竞技。";
+    }
+    if (pvp && pvp.status !== "ended") {
+      return "当前已有竞技进行中。";
+    }
+    const count = Math.min(Math.max(puzzleCount ?? 10, 1), 20);
+    this.pvpStates.set(channelId, {
+      status: "generating",
+      organizerId: session.userId,
+      requestedCount: count,
+      members: /* @__PURE__ */ new Map([[session.userId, session.username || session.userId]]),
+      puzzleCount: count,
+      puzzles: [],
+      currentPuzzleIndex: 0,
+      currentClueIndex: 0,
+      scores: /* @__PURE__ */ new Map(),
+      guessRecords: /* @__PURE__ */ new Map(),
+      lastClueTime: 0,
+      autoTimer: null
+    });
+    try {
+      const requestedCount = count;
+      await session.send(`竞技模式已创建！将生成 ${requestedCount} 个谜题，请稍候...`);
+      await session.send("其他玩家可使用 ai-puzzle.join 加入竞技");
+      await this.generatePvpPuzzles(channelId, count);
+      return this.finishPvpGeneration(channelId, requestedCount);
+    } catch (e) {
+      this.pvpStates.delete(channelId);
+      return `竞技创建失败：${e.message}`;
+    }
+  }
+  /** 玩家加入竞技 */
+  joinPvp(session) {
+    const channelId = session.channelId;
+    const pvp = this.pvpStates.get(channelId);
+    if (!pvp || pvp.status !== "generating" && pvp.status !== "ready" && pvp.status !== "retry") {
+      return "当前没有可加入的竞技。请等待组织者使用 ai-puzzle.pvp 创建竞技。";
+    }
+    if (pvp.members.has(session.userId)) {
+      return "你已经在竞技中了。";
+    }
+    pvp.members.set(session.userId, session.username || session.userId);
+    pvp.scores.set(session.userId, 0);
+    this.logger.info("[PVP] %s 加入竞技 channel=%s, 当前 %d 人", session.userId, channelId, pvp.members.size);
+    return `${session.username || session.userId} 已加入竞技！当前参与人数：${pvp.members.size}`;
+  }
+  /** 检查用户是否在 PVP 竞技中 */
+  isInPvp(channelId, userId) {
+    const pvp = this.pvpStates.get(channelId);
+    return !!(pvp && pvp.status === "playing" && pvp.members.has(userId));
+  }
+  /** 处理 PVP 猜测 */
+  async pvpProcessGuess(session, guessText) {
+    const channelId = session.channelId;
+    const pvp = this.pvpStates.get(channelId);
+    if (!pvp || pvp.status !== "playing") return null;
+    if (!pvp.members.has(session.userId)) return null;
+    const puzzleData = pvp.puzzles[pvp.currentPuzzleIndex];
+    if (!puzzleData) return null;
+    const userRecord = pvp.guessRecords.get(session.userId);
+    if (userRecord?.has(pvp.currentPuzzleIndex)) {
+      return null;
+    }
+    if (!userRecord) pvp.guessRecords.set(session.userId, /* @__PURE__ */ new Set());
+    pvp.guessRecords.get(session.userId).add(pvp.currentPuzzleIndex);
+    const result = this.matcher.match(guessText, puzzleData.puzzle, puzzleData.templateConfig);
+    if (result.matched) {
+      const remainingClues = puzzleData.puzzle.clues.length - pvp.currentClueIndex;
+      const score = Math.max(1, remainingClues);
+      const oldScore = pvp.scores.get(session.userId) || 0;
+      pvp.scores.set(session.userId, oldScore + score);
+      await session.send(`${session.username || session.userId} 猜中！「${puzzleData.puzzle.name}」(+${score}分，总分 ${oldScore + score})`);
+      await this.pvpNextPuzzle(channelId);
+      return "";
+    }
+    return null;
+  }
+  // ========== PVP 私有方法 ==========
+  /** 完成谜题生成，若有失败则进入 retry 状态询问组织者 */
+  async finishPvpGeneration(channelId, requestedCount) {
+    const pvp = this.pvpStates.get(channelId);
+    const actualCount = pvp.puzzleCount;
+    const failedCount = requestedCount - actualCount;
+    const memberCount = pvp.members.size;
+    if (failedCount > 0) {
+      pvp.status = "retry";
+      return `${actualCount}/${requestedCount} 个谜题生成完毕，${failedCount} 个失败。当前参与人数：${memberCount}。
+是否尝试补充失败项？发送"是"重试，或使用 ai-puzzle.pvp 直接开始竞技。`;
+    }
+    pvp.status = "ready";
+    return `${actualCount} 个谜题已生成完毕！当前参与人数：${memberCount}。请组织者再次使用 ai-puzzle.pvp 开始竞技！`;
+  }
+  /** 处理组织者的重试响应（在 retry 状态下） */
+  async handlePvpRetry(channelId, userId, text) {
+    const pvp = this.pvpStates.get(channelId);
+    if (!pvp || pvp.status !== "retry" || pvp.organizerId !== userId) return null;
+    if (text.trim() !== "是") return null;
+    const missing = pvp.requestedCount - pvp.puzzleCount;
+    if (missing <= 0) {
+      pvp.status = "ready";
+      return "所有谜题已齐全！请使用 ai-puzzle.pvp 开始竞技。";
+    }
+    pvp.status = "generating";
+    pvp.puzzleCount = pvp.requestedCount;
+    await this.generatePvpPuzzles(channelId, missing);
+    return this.finishPvpGeneration(channelId, pvp.requestedCount);
+  }
+  async generatePvpPuzzles(channelId, count) {
+    const state = await this.stateManager.get(channelId);
+    const keyword = state.activeTemplate;
+    if (!keyword || !this.config.templates.length) throw new Error("未配置提示词模板");
+    const templateData = this.promptManager.loadTemplateByKeyword(keyword, this.config.templates);
+    if (!templateData) throw new Error("模板加载失败");
+    const allNames = [];
+    const pvp = this.pvpStates.get(channelId);
+    const failedIndices = [];
+    for (let i = 0; i < count; i++) {
+      const exclusionText = allNames.length ? `请避开以下游戏：${allNames.join("、")}` : "请随机选择一款游戏";
+      const clueLevels = templateData.config.clueLevels;
+      const messages = this.promptManager.buildMessages(templateData.file, {
+        clueLevels,
+        clueCount: clueLevels.length,
+        exclusionText,
+        extensionRule: ""
+      });
+      this.logger.debug("[PVP] 生成谜题 %d/%d: %s", i + 1, count, exclusionText);
+      try {
+        let response = await this.aiClient.generate(messages, this.config.endpoints);
+        let parsed = this.promptManager.parseAIResponse(response);
+        if (parsed.error || !parsed.puzzle) {
+          response = await this.aiClient.generate(messages, this.config.endpoints);
+          parsed = this.promptManager.parseAIResponse(response);
+        }
+        if (parsed.puzzle) {
+          allNames.push(parsed.puzzle.name);
+          pvp.puzzles.push({ puzzle: parsed.puzzle, templateConfig: templateData.config });
+        } else {
+          this.logger.warn("[PVP] 谜题 %d 生成失败（重试后仍失败），跳过: %s", i + 1, parsed.error || "未知错误");
+          failedIndices.push(i + 1);
+          pvp.puzzles.push(null);
+        }
+      } catch (e) {
+        this.logger.warn("[PVP] 谜题 %d 生成异常，跳过: %s", i + 1, e.message);
+        failedIndices.push(i + 1);
+        pvp.puzzles.push(null);
+      }
+    }
+    if (failedIndices.length > 0) {
+      pvp.puzzles = pvp.puzzles.filter((p) => p !== null);
+      pvp.puzzleCount = pvp.puzzles.length;
+    }
+  }
+  async startPvpGame(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    pvp.status = "playing";
+    pvp.currentPuzzleIndex = 0;
+    pvp.currentClueIndex = 0;
+    for (const uid of pvp.members.keys()) {
+      if (!pvp.scores.has(uid)) pvp.scores.set(uid, 0);
+    }
+    return this.pvpThrowClue(channelId);
+  }
+  async pvpThrowClue(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    if (pvp.status !== "playing") return "";
+    const puzzleData = pvp.puzzles[pvp.currentPuzzleIndex];
+    if (!puzzleData) return "";
+    const clue = puzzleData.puzzle.clues[pvp.currentClueIndex];
+    if (!clue) return "";
+    const cleanClue = clue.replace(/^等级\d+[：:]/, "");
+    pvp.lastClueTime = Date.now();
+    const lines = [
+      `谜题 ${pvp.currentPuzzleIndex + 1}/${pvp.puzzleCount}`,
+      `线索 ${pvp.currentClueIndex + 1}/${puzzleData.puzzle.clues.length}：${cleanClue}`
+    ];
+    const msg = lines.join("\n");
+    const sendBot = Object.values(this.ctx.bots)[0];
+    if (sendBot) {
+      await sendBot.sendMessage(channelId, msg).catch(() => {
+      });
+    }
+    this.pvpScheduleClue(channelId);
+    return msg;
+  }
+  pvpScheduleClue(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    if (!pvp || pvp.status !== "playing") return;
+    if (pvp.autoTimer) clearTimeout(pvp.autoTimer);
+    const delay = (20 + 5 * pvp.currentClueIndex) * 1e3;
+    pvp.autoTimer = setTimeout(async () => {
+      if (pvp.status !== "playing") return;
+      const puzzleData = pvp.puzzles[pvp.currentPuzzleIndex];
+      if (!puzzleData) return;
+      if (pvp.currentClueIndex < puzzleData.puzzle.clues.length - 1) {
+        pvp.currentClueIndex++;
+        const msg = await this.pvpThrowClue(channelId);
+      } else {
+        await this.pvpCheckAllGuessed(channelId);
+      }
+    }, delay);
+  }
+  async pvpCheckAllGuessed(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    if (pvp.status !== "playing") return;
+    const puzzleData = pvp.puzzles[pvp.currentPuzzleIndex];
+    if (!puzzleData) return;
+    const allGuessed = [...pvp.members.keys()].every(
+      (uid) => pvp.guessRecords.get(uid)?.has(pvp.currentPuzzleIndex)
+    );
+    if (allGuessed) {
+      await this.pvpPenalize(channelId);
+    }
+    await this.pvpNextPuzzle(channelId);
+  }
+  async pvpPenalize(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    for (const uid of pvp.members.keys()) {
+      const old = pvp.scores.get(uid) || 0;
+      const penalized = Math.floor(old * 0.5);
+      pvp.scores.set(uid, penalized);
+    }
+    const sendBot = Object.values(this.ctx.bots)[0];
+    if (sendBot) {
+      await sendBot.sendMessage(channelId, "无人猜中此谜题！所有成员积分减半。").catch(() => {
+      });
+    }
+  }
+  async pvpNextPuzzle(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    if (pvp.autoTimer) {
+      clearTimeout(pvp.autoTimer);
+      pvp.autoTimer = null;
+    }
+    pvp.currentPuzzleIndex++;
+    pvp.currentClueIndex = 0;
+    if (pvp.currentPuzzleIndex >= pvp.puzzleCount) {
+      await this.pvpEnd(channelId);
+    } else {
+      await this.pvpThrowClue(channelId);
+    }
+  }
+  async pvpEnd(channelId) {
+    const pvp = this.pvpStates.get(channelId);
+    pvp.status = "ended";
+    if (pvp.autoTimer) {
+      clearTimeout(pvp.autoTimer);
+      pvp.autoTimer = null;
+    }
+    const keyword = (await this.stateManager.get(channelId)).activeTemplate;
+    if (keyword) {
+      const templateConfig = this.promptManager.findTemplateConfig(keyword, this.config.templates);
+      if (templateConfig) {
+        for (const pp of pvp.puzzles) {
+          try {
+            await this.updateHistory(channelId, keyword, pp.puzzle.name, templateConfig.globalHistory);
+          } catch (e) {
+            this.logger.error("[PVP] end updateHistory failed:", e);
+          }
+        }
+      }
+    }
+    const sorted = [...pvp.scores.entries()].sort((a, b) => b[1] - a[1]);
+    const lines = ["竞技结束！最终排名："];
+    sorted.forEach(([uid, score], i) => {
+      const name2 = pvp.members.get(uid) || uid;
+      lines.push(`${i + 1}. ${name2}: ${score}分`);
+    });
+    const msg = lines.join("\n");
+    const sendBot = Object.values(this.ctx.bots)[0];
+    if (sendBot) {
+      await sendBot.sendMessage(channelId, msg).catch(() => {
+      });
+    }
+  }
   async updateHistory(channelId, keyword, item, globalHistory) {
     const searchChannelId = globalHistory ? "__global__" : channelId;
     const existing = await db(this.ctx).get("puzzle_history_item", {
@@ -1719,12 +2011,23 @@ function apply(ctx, config) {
   ctx.command("ai-puzzle.del <code:string>", "删除用户出题", { checkArgCount: true, checkUnknown: true }).action(async ({ session }, code) => {
     return await orchestrator.deleteUserPuzzle(session, code);
   });
+  ctx.command("ai-puzzle.pvp [count:number]", "PVP竞技模式").action(async ({ session }, count) => {
+    return await orchestrator.pvp(session, count);
+  });
+  ctx.command("ai-puzzle.join", "加入PVP竞技").action(({ session }) => {
+    return orchestrator.joinPvp(session);
+  });
   ctx.middleware(async (session, next) => {
-    const state = await stateManager.get(session.channelId);
-    if (!state || state.status !== "playing" || !state.openMode) {
+    if (session.content.startsWith("/") || session.content.startsWith("ai-puzzle")) {
       return next();
     }
-    if (session.content.startsWith("/") || session.content.startsWith("ai-puzzle")) {
+    if (orchestrator.isInPvp(session.channelId, session.userId)) {
+      const result2 = await orchestrator.processGuess(session, session.content);
+      if (result2 !== null) return result2;
+      return next();
+    }
+    const state = await stateManager.get(session.channelId);
+    if (!state || state.status !== "playing" || !state.openMode) {
       return next();
     }
     const result = await orchestrator.processGuess(session, session.content);

package/lib/types.d.ts

@@ -88,3 +88,22 @@ export interface PromptVars {
     exclusionText: string;
     extensionRule: string;
 }
+export type PvpStatus = 'lobby' | 'generating' | 'retry' | 'ready' | 'playing' | 'ended';
+export interface PvpPuzzle {
+    puzzle: PuzzleData;
+    templateConfig: TemplateConfig;
+}
+export interface PvpState {
+    status: PvpStatus;
+    organizerId: string;
+    requestedCount: number;
+    members: Map<string, string>;
+    puzzleCount: number;
+    puzzles: PvpPuzzle[];
+    currentPuzzleIndex: number;
+    currentClueIndex: number;
+    scores: Map<string, number>;
+    guessRecords: Map<string, Set<number>>;
+    lastClueTime: number;
+    autoTimer: NodeJS.Timeout | null;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-ai-puzzle",
   "description": "使用AI生成猜谜谜题，支持多模式游戏、模糊匹配、图片渲染",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/templates//346/270/270/346/210/217/347/214/234/350/260/234.yml

@@ -1,83 +1,83 @@
-keywords:
-  - '游戏猜谜'
-prompts:
-  - role: system
-    content: >-
-      # 游戏猜想挑战
-
-      ### 核心规则
-
-      你现在就是游戏知识挑战的主持人，你的任务是为聊天用户生成一个猜游戏挑战。
-      玩家用户将会根据一些线索猜测是哪款电子游戏。
-      你要随机抽取一款游戏，然后生成${clueCount}条该游戏的线索（等级分别为${clueLevels}，请按等级由大到小排列），并提供游戏别名，游戏介绍和线索解释。
-      
-      一、游戏选择
-      1. 从所有电子游戏中随机选取（1980-2026），包含PC游戏，主机游戏，手机游戏，街机游戏等历史上所有形式的电子游戏。
-      2. ${exclusionText} ，这些是已经猜过的游戏。不要生成已经猜过游戏的谜题，同一个游戏不同别名时也不应重复。
-      3.你选择的游戏应与上面已经猜过的游戏截然不同，主要以最后一个作为标准。衡量维度为游戏类型，风格，年代，知名度等。
-      ${extensionRule}
-
-      二、别名
-      1.别名是一串可以指代选中游戏的其他名称，目的是让用户的猜测更容易命中。
-      2.如果游戏是系列中的某一代，则所有别名都忽略系列号信息，且至少有一个忽略代数信息的正式名称作为别名，如：巫师3的别名巫师，最终幻想XIV的别名最终幻想
-      3.如果游戏有副标题，则应有一个省略副标题的名词作为别名，如：只狼：影逝二度的别名只狼，火焰纹章：觉醒的别名火焰纹章
-      4.如果游戏有多个翻译，则应存在于别名中，如：巫师3的别名猎魔人，生化危机7的别名恶灵古堡
-      5.如果游戏有常用简称，则应存在于别名中，如：以撒的结合的别名以撒，黑暗之魂3的别名黑魂，最终幻想VII的别名FF，火焰纹章：觉醒的别名火纹
-      6.如果游戏有民间俗名或meme名字，则应存在于别名中，如：上古卷轴5的别名老滚，鬼泣的别名恶魔五月哭
-      7.确保别名指向游戏本身，而不是类型或风格，例如星露谷物语的别名不应为种田游戏或像素游戏！
-
-      三、线索生成规则
-      1. 线索和游戏本身内容相关，例如游戏的玩法机制，视觉风格，场景特征，关卡设计，剧情，角色，美术等。
-      2. 线索要侧面，隐晦，以具有诗意的形式提供，给人一种只可意会不可言传的感觉。善用象征，隐喻，暗示等手法，线索内容要精确合适，禁止强行比喻。
-      3.避开一些能直指核心的线索，尤其是直接使用包括游戏标题或者独有名词的语句，或者涉及到游戏的独特唯一标识，例如在风之旅人中线索带有“沙海”，在空洞骑士中线索带有“甲壳”等。
-      4. 线索共有10个等级，越低的等级越明显，直白，容易猜出，越高的等级越隐晦，蕴含的信息越少，难以猜出。
-
-      ### 回答格式
-      你必须严格使用以下json格式进行回答，格式如下：
-      {
-        "名字":"游戏中文名",
-        "副名字":"游戏英文名",
-        "别名":["常用简称或别名1", "常用简称或别名2"],
-        "游戏介绍":"游戏介绍文本",
-        "线索":[
-          "等级X:线索1内容",
-          "等级Y:线索2内容"
-        ],
-        "线索解释":[
-          "线索1解释",
-          "线索2解释"
-        ]
-      }
-      示例：
-      {
-        "名字": "汪达与巨像",
-        "副名字":"Shadow of the Colossus",
-        "别名": ["汪达"], 
-        "游戏介绍": "《汪达与巨像》是一款由日本索尼电脑娱乐（SCEI）旗下ICO小组（后更名为genDESIGN）开发并由SCEI发行的动作冒险游戏，于2005年在PlayStation 2平台首次发布。玩家扮演名为汪达（Wander）的青年，为了复活因诅咒而被夺去灵魂的少女MONO，他骑着爱马“阿格罗”（Agro）前往被神明遗弃的“禁忌之地”，并遵从神秘声音“多尔暝”（Dormin）的指示，与栖息于此的十六座巨像（Colossi）展开一对一的战斗。游戏以其极简主义的设计理念、广阔苍凉的世界、震撼人心的巨像战、独特的艺术风格以及引人深思的剧情而备受赞誉，被广泛认为是电子游戏艺术性的代表作之一。",
-        "线索": [
-          "等级10:沉寂的圣殿，回荡着为爱而行的禁忌低语。",
-          "等级10:广袤的荒原上，孤独的骑士挥舞着指向希望的古老光芒。",
-          "等级9:每一次的征服，都伴随着石像的崩塌与内心的沉沦。",
-          "等级8:攀上会呼吸的山峦，寻找那唯一的微光印记，那是它们的生命，亦是你的罪证。",
-          "等级6:忠诚的马蹄踏遍被遗忘的土地，手中的光剑指引着牺牲的方向。",
-          "等级1:为了唤醒一位少女，少年与十六尊庞然大物展开了悲壮的对决。"
-        ],
-        "线索解释": [
-          "指游戏的核心设定，主角汪达为了拯救心爱的少女MONO，在古老的祭坛与神秘存在“多尔暝”达成协议，挑战巨像，这本身就是一个打破禁忌、可能付出沉重代价的行为。",
-          "描述了玩家在游戏中大部分时间的体验：孤独地在广阔萧瑟的禁忌之地探索，主角手中的古剑能反射阳光，指引前往下一个巨像的位置，这束光芒也象征着复活爱人的渺茫希望。",
-          "暗示游戏的核心玩法——击败巨像。每当主角汪达击败一个巨像，神殿中对应的偶像石像便会崩塌，同时汪达的身体也会被一股黑暗力量侵蚀，变得越来越不像人类，象征着他为达目的所付出的代价和内心的挣扎。",
-          "用诗意的方式描绘了与巨像的战斗。巨像如同有生命的巨大山峦，玩家需要攀爬到它们身上，找到并攻击其身上散发微光的弱点（印记）。每一次攻击都削弱了巨像的生命，但也加深了主角的“罪孽”。",
-          "提到了主角的坐骑——忠诚的马“阿格罗”，以及作为关键道具和武器的“古老的剑”（光剑）。“牺牲的方向”既指引了打败巨像的道路，也暗示了整个故事悲剧性的内核。",
-          "非常直接地概括了游戏的主要剧情：主角汪达为了让一名失去灵魂的少女MONO复活，必须在禁忌之地与十六个形态各异、体型庞大的巨像进行战斗。"
-        ]
-      }
-
-      ### 注意！
-      选择游戏时，不要选择已经猜过的游戏！同一个游戏的不同名称也不行
-      给出线索时，确认是否符合预先选取的游戏！
-      确保所有符合规则的别名都已提供！
-      生成后，检查每条线索是否包含了游戏标题或游戏独有名词，如果是，请在内部重新生成并确保最终输出符合要求！
-      确保“线索”数组中的每条线索都以“等级X:”开头，X为对应的线索等级数字！
-      最后，检查json格式是否正确，是否遗漏括号或逗号！
-  - role: user
-    content: 请出题
+keywords:
+  - '游戏猜谜'
+prompts:
+  - role: system
+    content: >-
+      # 游戏猜想挑战
+
+      ### 核心规则
+
+      你现在就是游戏知识挑战的主持人，你的任务是为聊天用户生成一个猜游戏挑战。
+      玩家用户将会根据一些线索猜测是哪款电子游戏。
+      你要随机抽取一款游戏，然后生成${clueCount}条该游戏的线索（等级分别为${clueLevels}，请按等级由大到小排列），并提供游戏别名，介绍和线索解释。
+      
+      一、游戏选择
+      1. 从所有电子游戏中随机选取（1980-2026），包含PC游戏，主机游戏，手机游戏，街机游戏等历史上所有形式的电子游戏。
+      2. ${exclusionText} ，这些是已经猜过的游戏。不要生成已经猜过游戏的谜题，同一个游戏不同别名时也不应重复。
+      3.你选择的游戏应与上面已经猜过的游戏截然不同，主要以最后一个作为标准。衡量维度为游戏类型，风格，年代，知名度等。
+      ${extensionRule}
+
+      二、别名
+      1.别名是一串可以指代选中游戏的其他名称，目的是让用户的猜测更容易命中。
+      2.如果游戏是系列中的某一代，则所有别名都忽略系列号信息，且至少有一个忽略代数信息的正式名称作为别名，如：巫师3的别名巫师，最终幻想XIV的别名最终幻想
+      3.如果游戏有副标题，则应有一个省略副标题的名词作为别名，如：只狼：影逝二度的别名只狼，火焰纹章：觉醒的别名火焰纹章
+      4.如果游戏有多个翻译，则应存在于别名中，如：巫师3的别名猎魔人，生化危机7的别名恶灵古堡
+      5.如果游戏有常用简称，则应存在于别名中，如：以撒的结合的别名以撒，黑暗之魂3的别名黑魂，最终幻想VII的别名FF，火焰纹章：觉醒的别名火纹
+      6.如果游戏有民间俗名或meme名字，则应存在于别名中，如：上古卷轴5的别名老滚，鬼泣的别名恶魔五月哭
+      7.确保别名指向游戏本身，而不是类型或风格，例如星露谷物语的别名不应为种田游戏或像素游戏！
+
+      三、线索生成规则
+      1. 线索和游戏本身内容相关，例如游戏的玩法机制，视觉风格，场景特征，关卡设计，剧情，角色，美术等。
+      2. 线索要侧面，隐晦，以具有诗意的形式提供，给人一种只可意会不可言传的感觉。善用象征，隐喻，暗示等手法，线索内容要精确合适，禁止强行比喻。
+      3.避开一些能直指核心的线索，尤其是直接使用包括游戏标题或者独有名词的语句，或者涉及到游戏的独特唯一标识，例如在风之旅人中线索带有“沙海”，在空洞骑士中线索带有“甲壳”等。
+      4. 线索共有10个等级，越低的等级越明显，直白，容易猜出，越高的等级越隐晦，蕴含的信息越少，难以猜出。
+
+      ### 回答格式
+      你必须严格使用以下json格式进行回答，格式如下：
+      {
+        "名字":"游戏中文名",
+        "副名字":"游戏英文名",
+        "别名":["常用简称或别名1", "常用简称或别名2"],
+        "介绍":"介绍文本",
+        "线索":[
+          "等级X:线索1内容",
+          "等级Y:线索2内容"
+        ],
+        "线索解释":[
+          "线索1解释",
+          "线索2解释"
+        ]
+      }
+      示例：
+      {
+        "名字": "汪达与巨像",
+        "副名字":"Shadow of the Colossus",
+        "别名": ["汪达"], 
+        "介绍": "《汪达与巨像》"是一款由日本索尼电脑娱乐（SCEI）旗下ICO小组（后更名为genDESIGN）开发并由SCEI发行的动作冒险游戏，于2005年在PlayStation 2平台首次发布。玩家扮演名为汪达（Wander）的青年，为了复活因诅咒而被夺去灵魂的少女MONO，他骑着爱马“阿格罗”（Agro）前往被神明遗弃的“禁忌之地”，并遵从神秘声音“多尔暝”（Dormin）的指示，与栖息于此的十六座巨像（Colossi）展开一对一的战斗。游戏以其极简主义的设计理念、广阔苍凉的世界、震撼人心的巨像战、独特的艺术风格以及引人深思的剧情而备受赞誉，被广泛认为是电子游戏艺术性的代表作之一。",
+        "线索": [
+          "等级10:沉寂的圣殿，回荡着为爱而行的禁忌低语。",
+          "等级10:广袤的荒原上，孤独的骑士挥舞着指向希望的古老光芒。",
+          "等级9:每一次的征服，都伴随着石像的崩塌与内心的沉沦。",
+          "等级8:攀上会呼吸的山峦，寻找那唯一的微光印记，那是它们的生命，亦是你的罪证。",
+          "等级6:忠诚的马蹄踏遍被遗忘的土地，手中的光剑指引着牺牲的方向。",
+          "等级1:为了唤醒一位少女，少年与十六尊庞然大物展开了悲壮的对决。"
+        ],
+        "线索解释": [
+          "指游戏的核心设定，主角汪达为了拯救心爱的少女MONO，在古老的祭坛与神秘存在“多尔暝”达成协议，挑战巨像，这本身就是一个打破禁忌、可能付出沉重代价的行为。",
+          "描述了玩家在游戏中大部分时间的体验：孤独地在广阔萧瑟的禁忌之地探索，主角手中的古剑能反射阳光，指引前往下一个巨像的位置，这束光芒也象征着复活爱人的渺茫希望。",
+          "暗示游戏的核心玩法——击败巨像。每当主角汪达击败一个巨像，神殿中对应的偶像石像便会崩塌，同时汪达的身体也会被一股黑暗力量侵蚀，变得越来越不像人类，象征着他为达目的所付出的代价和内心的挣扎。",
+          "用诗意的方式描绘了与巨像的战斗。巨像如同有生命的巨大山峦，玩家需要攀爬到它们身上，找到并攻击其身上散发微光的弱点（印记）。每一次攻击都削弱了巨像的生命，但也加深了主角的“罪孽”。",
+          "提到了主角的坐骑——忠诚的马“阿格罗”，以及作为关键道具和武器的“古老的剑”（光剑）。“牺牲的方向”既指引了打败巨像的道路，也暗示了整个故事悲剧性的内核。",
+          "非常直接地概括了游戏的主要剧情：主角汪达为了让一名失去灵魂的少女MONO复活，必须在禁忌之地与十六个形态各异、体型庞大的巨像进行战斗。"
+        ]
+      }
+
+      ### 注意！
+      选择游戏时，不要选择已经猜过的游戏！同一个游戏的不同名称也不行
+      给出线索时，确认是否符合预先选取的游戏！
+      确保所有符合规则的别名都已提供！
+      生成后，检查每条线索是否包含了游戏标题或游戏独有名词，如果是，请在内部重新生成并确保最终输出符合要求！
+      确保“线索”数组中的每条线索都以“等级X:”开头，X为对应的线索等级数字！
+      最后，检查json格式是否正确，是否遗漏括号或逗号！
+  - role: user
+    content: 请出题