koishi-plugin-satori-ai 1.3.5 → 1.3.7

package/lib/gameOneTouch.d.ts

@@ -41,6 +41,7 @@ declare class OneTouchSingleGame extends abstractGameSingleGame {
     private evaluateState;
     private generateChat;
     private instuction;
+    private skillList;
 }
 export declare class OneTouchGame extends abstractGame<OneTouchSingleGame> {
     constructor();

package/lib/index.js

@@ -284,11 +284,11 @@ function filterResponse(prompt, words) {
   const lastAnswer5 = answerMatches5 ? answerMatches5[answerMatches5.length - 1] : null;
   const answerContent = lastAnswer || lastDoubao || lastAnswer3 || lastAnswer4 || lastAnswer5;
   if (!answerContent) {
-    return { content: "有点问题，稍后再来吧", error: true };
+    return { content: "有点问题，请重置对话", error: true };
   }
   const regex = /<p>|<\/p>|<doubaothinking>|<\/doubaothinking>|<\/p|<answer>|<\/answer>|<br>|<\/br>|<br\/>/g;
   const cleanedContent = answerContent.replace(regex, "");
-  return cleanedContent ? { content: cleanedContent, error: false } : { content: "有点问题，稍后再来吧", error: true };
+  return cleanedContent ? { content: cleanedContent, error: false } : { content: "有点问题，请重置对话", error: true };
 }
 __name(filterResponse, "filterResponse");
 function addOutputCensor(session, word, baseURL) {
@@ -311,6 +311,45 @@ async function updateUserPWithTicket(ctx, user, adjustment) {
   }
 }
 __name(updateUserPWithTicket, "updateUserPWithTicket");
+function findLongestCommonSubstring(str1, str2) {
+  if (!str1 || !str2)
+    return 0;
+  const m = str1.length;
+  const n = str2.length;
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+  let maxLength = 0;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+        maxLength = Math.max(maxLength, dp[i][j]);
+      }
+    }
+  }
+  return maxLength;
+}
+__name(findLongestCommonSubstring, "findLongestCommonSubstring");
+function countCommonChars(str1, str2) {
+  const chars1 = /* @__PURE__ */ new Map();
+  const chars2 = /* @__PURE__ */ new Map();
+  for (const char of str1) {
+    if (/[\u4e00-\u9fff]/.test(char)) {
+      chars1.set(char, (chars1.get(char) || 0) + 1);
+    }
+  }
+  for (const char of str2) {
+    if (/[\u4e00-\u9fff]/.test(char)) {
+      chars2.set(char, (chars2.get(char) || 0) + 1);
+    }
+  }
+  let commonCount = 0;
+  for (const [char, count1] of chars1) {
+    const count2 = chars2.get(char) || 0;
+    commonCount += Math.min(count1, count2);
+  }
+  return commonCount;
+}
+__name(countCommonChars, "countCommonChars");
 
 // src/api.ts
 var logger2 = new import_koishi2.Logger("satori-api");
@@ -607,7 +646,7 @@ var MemoryManager = class {
       return acc;
     }, []);
     const filtered = sentences.filter((sentence) => !filterWords.some((word) => sentence.includes(word))).join("");
-    const result = filtered.replace(/([，、])\1+/g, "$1").replace(/^[，。！？;,.!?]+/, "").trim();
+    const result = filtered.replace(/([，、…])\1+/g, "$1").replace(/^[，。！？;,.!?]+/, "").trim();
     return result || content;
   }
   // 更新短期记忆
@@ -702,22 +741,12 @@ var MemoryManager = class {
   calculateMatchScore(content, keywords) {
     if (keywords.length === 0)
       return { score: 0, count: 0 };
-    const escapedKeywords = keywords.map((k) => escapeRegExp(k));
-    const regex = new RegExp(escapedKeywords.join("|"), "gi");
-    const chineseRegex = /[\u4e00-\u9fa5]/g;
-    const regex2 = new RegExp(`[${this.charactersToRemove.join("")}]`, "g");
-    content = content.replace(regex2, "");
-    const matches = content.match(regex) || [];
-    let count = 0;
-    matches.forEach((match) => {
-      const chineseCount = (match.match(chineseRegex) || []).length;
-      const englishCount = match.length - chineseCount;
-      count += chineseCount * 2 + englishCount;
-    });
-    const totalChinese = (content.match(chineseRegex) || []).length;
-    const totalEnglish = content.length - totalChinese;
-    const totalWeight = totalChinese * 2 + totalEnglish;
-    const ratio = totalWeight > 0 ? count / totalWeight : 0;
+    const regex = new RegExp(`[${this.charactersToRemove.join("")}]`, "g");
+    content = content.replace(regex, "");
+    const Keyword = keywords.map((k) => escapeRegExp(k)).join("");
+    const length = findLongestCommonSubstring(content, Keyword);
+    const count = countCommonChars(content, Keyword);
+    const ratio = (length * length + count) / content.length;
     return { score: ratio, count };
   }
   // 格式化匹配结果
@@ -732,7 +761,8 @@ var MemoryManager = class {
       matched = matched.slice(0, topN < matched.length ? topN : matched.length);
       if (type === "common") {
         const result = `${prefixMap[type]}{
-${matched.map((entry) => entry.content).join("\n")} ${date}
+${matched.map((entry) => entry.content).join("\n")} 
+${date}
 }
 `;
         return result;
@@ -1028,7 +1058,7 @@ function createMiddleware(ctx, sat, config) {
   return async (session, next) => {
     if (config.enable_favorability && config.enable_warning && session.channelId === config.warning_group)
       sat.getWarningList(session);
-    sat.broadcastManager.seedBroadcast(session);
+    await sat.broadcastManager.seedBroadcast(session);
     if (!isSpecialMessage(session))
       await sat.handleChannelMemoryManager(session);
     if (config.private && isPrivateSession(session)) {
@@ -1297,12 +1327,11 @@ var UserPortraitManager = class {
     return [{
       role: "user",
       content: `你是一个角色扮演智能体工作流中的一环，请根据以下信息更新用户画像。需包括：
-1. 基本信息（性别、年龄、生日等）
+1. 基本信息（性别、年龄、生日等，不要遗漏或改动已有的信息）
 2. 生活习惯（作息等）
 3. 反感点（如有）
 4. 对AI的期望（从对话历史中推断）
 5. 用户希望记住的信息（如有）
-6. 需要短期记忆的信息（如有）
 
 用户名：${user.usersname}
 你与用户的关系：${level}
@@ -1315,9 +1344,7 @@ ${history}
 注意事项：
 ·用户一定是人类，其他情况是角色扮演
 ·根据发言修正历史画像内容，但是历史画像中与发言无关的部分必须保留
-·除非用户要求，否则不要删除基本信息中的内容
 ·尤其注意用户说“记住”的部分，可能是用户希望记录的信息
-·历史画像中的需要短期记忆的信息不需要保留，只需要删除旧的添加新的
 ·因为在角色扮演中，用户可能会说出不符合事实的信息，需要根据事实推断，避免盲目相信或主观臆测
 ·使用尽可能简洁的表达
 ·保留不确定性的表述（如"可能"、"似乎"、"用户自称"）
@@ -1453,7 +1480,6 @@ var MoodManager = class {
     const userId = user.userid;
     if (!this.moodMap.has(userId))
       this.initUser(userId);
-    await this.checkDailyReset(userId);
     let effect = this.config.value_of_input_mood;
     switch (favorabilityLevel) {
       case "厌恶":
@@ -1489,7 +1515,6 @@ var MoodManager = class {
     const userId = user.userid;
     if (!this.moodMap.has(userId))
       this.initUser(userId);
-    await this.checkDailyReset(userId);
     let effect = this.config.value_of_output_mood;
     switch (favorabilityLevel) {
       case "厌恶":
@@ -1519,7 +1544,7 @@ var MoodManager = class {
     return;
   }
   // 应用心情变化
-  applyMoodChange(user, delta) {
+  async applyMoodChange(user, delta) {
     if (!this.config.enable_mood)
       return;
     const userId = user.userid;
@@ -1533,6 +1558,7 @@ var MoodManager = class {
       mood: newMood,
       lastUpdate: Date.now()
     });
+    await this.checkDailyReset(userId);
     return;
   }
   // 获取心情等级
@@ -2176,7 +2202,7 @@ var import_koishi11 = require("koishi");
 var logger10 = new import_koishi11.Logger("satori-game-onetouch");
 var SKILL_MAP = {
   // 基础技能
-  "-1": { name: "无效" },
+  "-1": {},
   "1": { pierceDamage: 1, bleed: 3, name: "锥刺" },
   //特性：流血
   "2": { pierceDamage: 1, stun: true, name: "点穴" },
@@ -2230,7 +2256,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   // 当前回合数
   baseHP = 40;
   // 初始血量
-  playerLevelHP = 8;
+  playerLevelHP = 10;
   // 每级增加的血量
   aiLevelHp = 10;
   // AI每级增加的血量
@@ -2271,6 +2297,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
 例如"左 右"表示用你的左手触碰对方的右手
 注：
 发送"游戏规则"查看游戏规则
+发送"技能列表"查看技能列表
 发送"结束游戏"退出游戏`);
   }
   // 结束游戏，返回结果
@@ -2292,7 +2319,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       left: this.player.left,
       right: this.player.right,
       hp: this.baseHP + level * this.playerLevelHP,
-      shield: Math.round(5 - level / 2),
+      shield: Math.round(6 - level / 2),
       strength: 0,
       bleed: 0,
       counterAttack: 0,
@@ -2314,6 +2341,8 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   async processInput(input) {
     if (input === "游戏规则")
       return await wrapInHTML2(this.instuction);
+    if (input === "技能列表")
+      return await wrapInHTML2(this.skillList);
     if (this.turnCount === 0)
       this.initState(this.level);
     this.turnCount++;
@@ -2374,11 +2403,11 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   judgeEnd() {
     if (this.ai.hp <= 0) {
       this.winningFlag = 1 /* win */;
-      return `你赢了！发送结束游戏退出`;
+      return `你赢了！发送"结束游戏"退出`;
     }
     if (this.player.hp <= 0) {
       this.winningFlag = 2 /* lose */;
-      return `你输了！发送结束游戏退出`;
+      return `你输了！发送"结束游戏"退出`;
     }
   }
   processPlayerTurn(handA, handB) {
@@ -2388,7 +2417,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
     if (this.player.status === 1 /* Stunned */) {
       this.player.status = 2 /* lastStunned */;
       this.applyEffect(this.player, this.ai, SKILL_MAP["-1"], false);
-      return "你被眩晕，跳过回合";
+      return "你被眩晕，跳过回合" + this.buildResultMessage(SKILL_MAP["-1"], false, this.player, this.ai);
     }
     const sum = (handA + handB) % 10;
     this.player[handA === this.player.left ? "left" : "right"] = sum;
@@ -2521,7 +2550,7 @@ ${bonusMessage}` : "");
     if (this.ai.status === 1 /* Stunned */) {
       this.ai.status = 2 /* lastStunned */;
       this.applyEffect(this.ai, this.player, SKILL_MAP["-1"], false);
-      return "被眩晕，跳过回合，本回合分数奖励继承到下一回合";
+      return "被眩晕，跳过回合，本回合分数奖励继承到下一回合" + this.buildResultMessage(SKILL_MAP["-1"], false, this.ai, this.player);
     }
     const sum = (handA + handB) % 10;
     this.ai[handA === this.ai.left ? "left" : "right"] = sum;
@@ -2873,10 +2902,10 @@ ${bonusMessage}` : "");
     if (this.lastScore < 9e4 && Score > 9e4) {
       return "我觉得你要输了哦~";
     }
-    if (this.lastScore < 0 && Score > 0) {
+    if (this.lastScore < 0 && Score > 0 && Math.random() > 0.5) {
       return "局势发生变化了呢~";
     }
-    if (Score - this.lastScore > 10 && Math.random() > 0.5)
+    if (Score - this.lastScore > 10 && Math.random() > 0.8)
       return "看招！";
   }
   instuction = `游戏说明：
@@ -2889,9 +2918,23 @@ ${bonusMessage}` : "");
   当自身两手手势相同时，无论选择左手还是右手最终发生变化的都是左手。
   玩家初始有"${this.baseHP} + ${this.playerLevelHP} * 难度"血量。
   ai初始有"${this.baseHP} + ${this.aiLevelHp} * 难度"血量。
-  玩家初始有"5 - 难度 / 2"护盾，四舍五入取整。
+  玩家初始有"6 - 难度 / 2"护盾，四舍五入取整。
   血量没有上限，率先将对方血量减到零的人获胜：
-  具体的技能设计如下：{
+
+  游戏名称说明：
+  流血效果：每次到自己回合结束时，收到流血层数点伤害，不可被护盾阻挡，然后流血层数减1;
+  护盾效果：每一层护盾可阻挡下一次受到的普通伤害，如果伤害来源是组合技则消耗两层护盾(若仅有一层则消耗一层)。护盾上限为五层。
+  眩晕效果：跳过自己的下一个回合，若上回合已经被眩晕，则本回合不受眩晕影响（即不可被连续眩晕）
+  弱眩晕效果：若对方没有护盾，则眩晕对方一回合
+  反击：下一回合若对方行动中有攻击，则对方攻击前受到反击层数点穿刺伤害，此效果受力量加成，且仅持续一回合
+  穿刺伤害：不被护盾影响的伤害（不会消耗护盾）
+  力量效果：每有一点力量，每次造成的伤害+1，若为负数则减一
+  易伤效果：受到的普通伤害+50%，自己的回合结束时减少一层
+  组合技：在触碰完成后，若你的两只手手势符合组合技条件，则触发组合技，组合技的效果会覆盖普通技能的效果，组合无序
+  bonus: 当行动导致关键效果时，获得额外奖励，在ai回合结束时结算，若ai被眩晕则奖励继承到下一回合
+  `;
+  skillList = `
+  具体的技能设计如下：
   一：${SKILL_MAP["1"].name}：造成${SKILL_MAP["1"].pierceDamage}穿刺伤害，${SKILL_MAP["1"].bleed}流血;
   二：${SKILL_MAP["2"].name}：造成${SKILL_MAP["2"].pierceDamage}穿刺伤害，眩晕对方；
   三：${SKILL_MAP["3"].name}：造成${SKILL_MAP["3"].damage}伤害，获得${SKILL_MAP["3"].counterAttack}层反击；
@@ -2921,18 +2964,6 @@ ${bonusMessage}` : "");
   三+七：${SKILL_MAP["3+7"].name}：获得${SKILL_MAP["3+7"].counterAttack}层反击，破坏对方${SKILL_MAP["3+7"].destroyShield}层护盾，对方左手数值增加${SKILL_MAP["3+7"].addLeft}，右手数值增加${SKILL_MAP["3+7"].addRight}
   九+十：${SKILL_MAP["0+9"].name}：逆转双方力量，然后增加自身${SKILL_MAP["0+9"].selfstrengthChange}力量，对方${SKILL_MAP["0+9"].strengthChange}力量
   十+十：${SKILL_MAP["0+0"].name}：对对方造成${SKILL_MAP["0+0"].bleed}流血，自身${SKILL_MAP["0+0"].selfstrengthChange}力量，然后立即结算对方全部流血
-  }
-  注：
-  流血效果：每次到自己回合结束时，收到流血层数点伤害，不可被护盾阻挡，然后流血层数减1;
-  护盾效果：每一层护盾可阻挡下一次受到的普通伤害，如果伤害来源是组合技则消耗两层护盾(若仅有一层则消耗一层)。护盾上限为五层。
-  眩晕效果：跳过自己的下一个回合，若上回合已经被眩晕，则本回合不受眩晕影响（即不可被连续眩晕）
-  弱眩晕效果：若对方没有护盾，则眩晕对方一回合
-  反击：下一回合若对方行动中有攻击，则对方攻击前受到反击层数点穿刺伤害，此效果受力量加成，且仅持续一回合
-  穿刺伤害：不被护盾影响的伤害（不会消耗护盾）
-  力量效果：每有一点力量，每次造成的伤害+1，若为负数则减一
-  易伤效果：受到的普通伤害+50%，自己的回合结束时减少一层
-  组合技：两只手势符合组合技条件时触发组合技，组合技的效果会覆盖普通技能的效果，组合无序
-  bonus: 当行动导致关键效果时，获得额外奖励，在ai回合结束时结算，若ai被眩晕则奖励继承到下一回合
   `;
 };
 var OneTouchGame = class extends abstractGame {
@@ -3234,13 +3265,13 @@ var broadcastMessage = class {
     if (this.alreadySentChannels.has(channelId))
       return;
     try {
+      this.alreadySentChannels.add(channelId);
       if (this.img) {
         session.send(await wrapInHTML3(this.message));
       } else {
         session.send(this.message);
       }
       logger12.info(`向群 ${channelId} 广播: ${this.message}`);
-      this.alreadySentChannels.add(channelId);
     } catch (error) {
       logger12.error(`广播失败 ${channelId}: ${error}`);
     }
@@ -3663,7 +3694,7 @@ ${payload}`);
   getThinkingPrompt(user, prompt) {
     const reasonerPrompt = this.config.reasoner_prompt;
     const promptForNoReasoner = `#请你在回复时先进行分析思考，并且模仿思维链的模式输出思考内容，${reasonerPrompt};
-#你在思考时必须以 "<think>" 开头, "</think>" 结尾。仔细揣摩用户意图，完整输出思考内容后在输出正式的回复内容;
+#你在思考时必须以 "<think>" 开头, "</think>" 结尾。仔细揣摩用户意图，**完整输出思考内容后**再输出正式的回复内容;
 #注意：你的正式回复内容必须使用“<p>”开头，使用“</p>”结尾，并且无论如何都要把标签输出完整
 `;
     const promptForReasoner = `#你在思考时必须以 "嗯" 开头。仔细揣摩用户意图，思考结束后返回符合要求的回复。
@@ -3765,7 +3796,7 @@ ${useNoReasoner ? promptForNoReasoner : promptForReasoner}
     const filePath = path7.join(this.config.dataDir, "common_sense.txt");
     await this.memoryManager.saveLongTermMemory(session, [{
       role: "user",
-      content
+      content: content.replace(/\"/g, "'").trim()
     }], filePath);
     return session.text("commands.sat.common_sense.messages.succeed", [content]);
   }

package/lib/mood.d.ts

@@ -9,7 +9,7 @@ export declare class MoodManager {
     private checkDailyReset;
     handleInputMoodChange(user: User, favorabilityLevel: string): Promise<void>;
     handleOutputMoodChange(user: User, favorabilityLevel: string): Promise<void>;
-    applyMoodChange(user: User, delta: number): void;
+    applyMoodChange(user: User, delta: number): Promise<void>;
     getMoodLevel(userId: string): string;
     getMoodValue(userId: string): number;
     generateMoodPrompt(userId: string): string;

package/lib/utils.d.ts

@@ -29,3 +29,5 @@ export declare function filterResponse(prompt: string, words: string[]): {
 };
 export declare function addOutputCensor(session: Session, word: string, baseURL: string): void;
 export declare function updateUserPWithTicket(ctx: Context, user: User, adjustment: number): Promise<void>;
+export declare function findLongestCommonSubstring(str1: string, str2: string): number;
+export declare function countCommonChars(str1: string, str2: string): number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-satori-ai",
   "description": "基于 Satori 适配器的智能对话插件，具备用户画像、长期记忆、常识管理和好感度系统",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "types": "lib/index.d.ts",