koishi-plugin-satori-ai 1.3.3 → 1.3.4

package/lib/gameOneTouch.d.ts

@@ -3,8 +3,7 @@ import { abstractGame, abstractGameSingleGame, gameResult } from './abstractGame
 import { winFlag } from './game';
 export interface OneTouchResult extends gameResult {
     win: winFlag;
-    message: string;
-    playerId: number;
+    bonus: number;
 }
 declare class OneTouchSingleGame extends abstractGameSingleGame {
     private player;
@@ -16,20 +15,21 @@ declare class OneTouchSingleGame extends abstractGameSingleGame {
     private playerLevelHP;
     private aiLevelHp;
     private lastScore;
+    private bonus;
+    private singleBonus;
+    private singleBonusMultiplier;
+    private comboCombos;
     constructor(disposeListener: () => boolean, session: Session);
     startGame(): Promise<string>;
-    endGame: () => Promise<{
-        message: string;
-        win: winFlag;
-        gameName: string;
-        playerID: string;
-    }>;
+    endGame: () => Promise<OneTouchResult>;
     private initState;
     processInput(input: string): Promise<string>;
     private buildTurnResult;
     private judgeEnd;
     private processPlayerTurn;
+    private buildMyTurnBonusMessage;
     private processAiTurn;
+    private buildAiTurnBonusMessage;
     private applyEffectToEnemy;
     private applyEffectToSelf;
     private checkCombo;

package/lib/index.js

@@ -474,7 +474,7 @@ var APIClient = class {
         continue;
       }
     }
-    return { content: "模型发生复读行为，建议重置对话", error: true };
+    return { content: "unreachable", error: true };
   }
   // 生成请求头
   createHeaders(keys) {
@@ -2171,17 +2171,27 @@ var import_koishi11 = require("koishi");
 var logger10 = new import_koishi11.Logger("satori-game-onetouch");
 var SKILL_MAP = {
   // 基础技能
-  "-1": { damage: 0, name: "无效" },
+  "-1": { name: "无效" },
   "1": { pierceDamage: 1, bleed: 3, name: "锥刺" },
+  //特性：流血
   "2": { pierceDamage: 1, stun: true, name: "点穴" },
+  //特性：眩晕
   "3": { damage: 6, counterAttack: 3, name: "爪击" },
+  //特性：反击
   "4": { shield: 1, name: "护盾" },
+  //特性：护盾
   "5": { damage: 4, weakStun: true, name: "巴掌" },
+  //特性：普通伤害+弱眩晕
   "6": { heal: 6, selfbleed: -2, name: "酒" },
+  //特性：回血
   "7": { pierceDamage: 1, destroyShield: 2, name: "钻击" },
+  //特性：破盾
   "8": { damage: 13, selfStun: true, name: "枪击" },
+  //特性：高伤+自眩晕
   "9": { pierceDamage: 1, bleed: 2, strengthChange: -1, name: "钩" },
+  //特性：削弱
   "0": { selfstrengthChange: 2, name: "蓄力" },
+  //特性：蓄力
   // 组合技
   "1+8": { damage: 15, bleed: 3, selfStun: true, name: "空尖弹" },
   "5+5": { damage: 5, stun: true, name: "镇压" },
@@ -2199,6 +2209,7 @@ var SKILL_MAP = {
   "7+8": { pierceDamage: 13, destroyShield: 3, selfStun: true, name: "穿甲弹" },
   "2+6": { damage: 5, heal: 6, selfbleed: -1, selfstrengthChange: 1, stun: true, name: "点辰" },
   "3+7": { name: "混沌", counterAttack: 7, destroyShield: 2, addLeft: 9, addRight: 1 },
+  "0+9": { name: "将大局逆转吧", revwersalOfStrength: true },
   "0+0": { name: "华丽收场", bleed: 5, selfstrengthChange: -99, magnificentEnd: true }
 };
 var OneTouchSingleGame = class extends abstractGameSingleGame {
@@ -2220,12 +2231,22 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   // AI每级增加的血量
   lastScore = 0;
   // 上一回合的分数
+  bonus = 0;
+  // 奖励分数
+  singleBonus = 0;
+  // 单回合的分数
+  singleBonusMultiplier = 1;
+  // 单回合的分数倍率
+  comboCombos = 0;
+  // 组合技连击次数
   constructor(disposeListener, session) {
     super(disposeListener, session);
   }
   async startGame() {
     super.startGame();
     this.turnCount = 0;
+    this.bonus = 0;
+    this.comboCombos = 0;
     this.player = {
       left: Math.round(Math.random() * 8) + 1,
       right: Math.round(Math.random() * 8) + 1,
@@ -2249,16 +2270,25 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   }
   // 结束游戏，返回结果
   endGame = async () => {
+    if (this.winningFlag === 4 /* pending */ || this.winningFlag === 2 /* lose */) {
+      this.bonus = Math.abs(Math.floor(this.level * 0.2 * this.bonus));
+      this.bonus -= Math.floor(this.level * this.level * (Math.random() * 2 + 2) + 200);
+      this.bonus = Math.min(this.bonus, 0);
+    }
+    if (this.winningFlag === 1 /* win */) {
+      this.bonus = Math.floor(this.level * this.bonus * 0.2 * (Math.random() * 1 + 1));
+    }
+    const finalBonus = this.bonus;
     super.endGame();
-    return { message: `${this.level}`, win: this.winningFlag, gameName: "一碰一", playerID: this.session.userId };
+    return { win: this.winningFlag, gameName: "一碰一", playerID: this.session.userId, bonus: finalBonus, message: this.level.toString() };
   };
   initState(level) {
     this.player = {
       left: this.player.left,
       right: this.player.right,
       hp: this.baseHP + level * this.playerLevelHP,
-      shield: Math.round(level / 3),
-      strength: Math.round(level / 5),
+      shield: Math.round(level / 2),
+      strength: 0,
       bleed: 0,
       counterAttack: 0,
       vulnerablility: 0,
@@ -2282,17 +2312,17 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
     if (this.turnCount === 0)
       this.initState(this.level);
     this.turnCount++;
-    if (this.winningFlag !== 4 /* pending */)
-      return "游戏已结束";
     const [handA, handB] = input.split(" ");
     if (handA !== "左" && handA !== "右" || handB !== "左" && handB !== "右")
       return;
+    if (this.winningFlag !== 4 /* pending */)
+      return "游戏已结束";
     const numberA = this.player[handA === "左" ? "left" : "right"];
     const numberB = this.ai[handB === "左" ? "left" : "right"];
     const result = this.processPlayerTurn(numberA, numberB);
     const bestMove = this.ai.status === 1 /* Stunned */ ? [0, 0] : this.aiSearchEntrance();
     const aiResult = this.processAiTurn(bestMove[0], bestMove[1]);
-    if (this.player.status === 1 /* Stunned */)
+    if (this.player.status === 1 /* Stunned */ && this.player.hp > 0 && this.ai.hp > 0)
       setTimeout(async () => {
         this.session.send(await this.processInput(input));
       }, 1e3);
@@ -2302,7 +2332,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
     const createStatusBar = /* @__PURE__ */ __name((value, max, width) => `[${"■".repeat(Math.max(Math.ceil(value / max * width), 0))}${"□".repeat(width - Math.max(Math.ceil(value / max * width)))}]`, "createStatusBar");
     const statusIcon = /* @__PURE__ */ __name((value, icon) => value != 0 ? `${icon}×${value}` : "", "statusIcon");
     const aiStatusDisplay = [
-      `❤️${createStatusBar(this.ai.hp, Math.max(this.baseHP + this.level * this.aiLevelHp, this.ai.hp), Math.round(this.baseHP / 10 + this.level * this.aiLevelHp / this.playerLevelHP))} ${this.ai.hp}HP`,
+      `❤️${createStatusBar(this.ai.hp, Math.max(this.baseHP + this.level * this.aiLevelHp, this.ai.hp), Math.round(this.baseHP / 8 + this.level * this.aiLevelHp / this.playerLevelHP))} ${this.ai.hp}HP`,
       `🛡️${this.ai.shield}`,
       statusIcon(this.ai.bleed, "🩸"),
       statusIcon(this.ai.strength, "💪"),
@@ -2311,7 +2341,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       this.ai.status === 1 /* Stunned */ ? "💫 眩晕" : ""
     ].filter(Boolean).join(" | ");
     const playerStatusDisplay = [
-      `❤️${createStatusBar(this.player.hp, Math.max(this.baseHP + this.level * this.playerLevelHP, this.player.hp), Math.round(this.baseHP / 10 + this.level))} ${this.player.hp}HP`,
+      `❤️${createStatusBar(this.player.hp, Math.max(this.baseHP + this.level * this.playerLevelHP, this.player.hp), Math.round(this.baseHP / 8 + this.level))} ${this.player.hp}HP`,
       `🛡️${this.player.shield}`,
       statusIcon(this.player.bleed, "🩸"),
       statusIcon(this.player.strength, "💪"),
@@ -2319,9 +2349,9 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       statusIcon(this.player.vulnerablility, "💔"),
       this.player.status === 1 /* Stunned */ ? "💫 眩晕" : ""
     ].filter(Boolean).join(" | ");
-    return wrapInHTML2(`你的行动：${result}
+    return wrapInHTML2(`▶️你的行动：${result}
 
-我的行动：${aiResult}
+▶️我的行动：${aiResult}
 
   我的当前手势：左${this.ai.left} 右${this.ai.right}
   你的当前手势：左${this.player.left} 右${this.player.right}
@@ -2339,12 +2369,10 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   judgeEnd() {
     if (this.ai.hp <= 0) {
       this.winningFlag = 1 /* win */;
-      this.endGame();
       return `你赢了！发送结束游戏退出`;
     }
     if (this.player.hp <= 0) {
       this.winningFlag = 2 /* lose */;
-      this.endGame();
       return `你输了！发送结束游戏退出`;
     }
   }
@@ -2357,32 +2385,141 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       this.player = this.applyEffectToSelf(this.ai, this.player, SKILL_MAP["-1"]);
       return "你被眩晕，跳过回合";
     }
-    const playerState = this.player;
-    const aiState = this.ai;
     const sum = (handA + handB) % 10;
-    this.player[handA === playerState.left ? "left" : "right"] = sum;
+    this.player[handA === this.player.left ? "left" : "right"] = sum;
     let effect = SKILL_MAP[sum.toString()] || {};
     let isCombo = false;
     const combo = this.checkCombo(this.player["left"], this.player["right"]);
     if (combo) {
       isCombo = true;
+      this.comboCombos++;
       effect = { ...combo };
+    } else {
+      this.comboCombos = 0;
     }
+    const bonusMessage = this.buildMyTurnBonusMessage(effect, isCombo);
+    const playerState = this.player;
+    const aiState = this.ai;
     this.ai = this.applyEffectToEnemy(playerState, aiState, effect, !!combo);
     this.player = this.applyEffectToSelf(aiState, playerState, effect);
-    return this.buildResultMessage(effect, isCombo, this.player, this.ai);
+    return this.buildResultMessage(effect, isCombo, this.player, this.ai) + (bonusMessage ? `
+
+${bonusMessage}` : "");
+  }
+  // 生成玩家回合奖励信息
+  buildMyTurnBonusMessage(effect, isCombo) {
+    let bonusMessage = "";
+    this.singleBonus = 0;
+    this.singleBonusMultiplier = 1;
+    if (isCombo) {
+      this.singleBonus += 10;
+      bonusMessage += `触发组合技，获得10点分数!
+`;
+    }
+    if ((effect.damage || 0) * (effect.damageTimes || 1) >= 20 && this.ai.shield === 0) {
+      const effectBonus = Math.round((effect.damage || 0) * (effect.damageTimes || 1) * 0.8);
+      this.singleBonus += effectBonus;
+      bonusMessage += `沉重一击！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.pierceDamage || 0) >= 15) {
+      const effectBonus = Math.round(effect.pierceDamage * 0.5);
+      this.singleBonus += effectBonus;
+      bonusMessage += `穿刺一击！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.destroyShield || 0) >= Math.min(this.ai.shield, 3) && this.ai.shield > 1) {
+      const effectBonus = Math.round(this.ai.shield * 5);
+      this.singleBonus += effectBonus;
+      bonusMessage += `快速破盾！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.bleed || 0) + this.ai.bleed > 9) {
+      const effectBonus = Math.round(this.ai.bleed);
+      this.singleBonus += effectBonus;
+      bonusMessage += `流血打击！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.shield || 0) + this.player.shield >= 5) {
+      const effectBonus = Math.round(((effect.shield || 0) + this.player.shield) * 2);
+      this.singleBonus += effectBonus;
+      bonusMessage += `强效护盾！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.selfbleed || 0) < -2 && this.player.bleed > -effect.selfbleed) {
+      const effectBonus = Math.round(this.player.bleed * 2);
+      this.singleBonus += effectBonus;
+      bonusMessage += `关键治疗！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.stun || effect.weakStun && this.ai.shield === 0) && this.ai.status === 0 /* Normal */ && this.ai.bleed > 5) {
+      const effectBonus = Math.round(this.ai.bleed * 2);
+      this.singleBonus += effectBonus;
+      bonusMessage += `流血眩晕！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.strengthChange || 0) < -1 && this.ai.strength < 0) {
+      const effectBonus = Math.round(effect.strengthChange * -5);
+      this.singleBonus += effectBonus;
+      bonusMessage += `强效削弱！获得${effectBonus}点分数!
+`;
+    }
+    if (this.ai.counterAttack > 0 && !effect.damage && !effect.pierceDamage) {
+      const effectBonus = Math.round(this.ai.counterAttack);
+      this.singleBonus += effectBonus;
+      bonusMessage += `反击规避！获得${effectBonus}点分数!
+`;
+    }
+    if (this.player.hp < 10 && !this.player.shield && (effect.damage || effect.pierceDamage)) {
+      const effectBonus = (10 - this.player.hp) * 2;
+      this.singleBonus += effectBonus;
+      bonusMessage += `濒死反击！获得${effectBonus}点分数!
+`;
+    }
+    if (effect.revwersalOfStrength && this.player.strength <= this.ai.strength - 5) {
+      const effectBonus = Math.round((this.ai.strength - this.player.strength) * 3);
+      this.singleBonus += effectBonus;
+      bonusMessage += `逆转大局！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.damage || 0) + (effect.pierceDamage || 0) >= 10 && this.ai.vulnerablility > 0) {
+      const effectBonus = this.ai.vulnerablility * 0.1;
+      this.singleBonusMultiplier += effectBonus;
+      bonusMessage += `易伤打击！本回合分数增加${100 * effectBonus}%!
+`;
+    }
+    if (this.turnCount === 4 + Math.round(this.level / 3) && this.player.hp > this.ai.hp * 1.2 && this.player.shield > this.ai.shield && this.player.strength > this.ai.strength && this.player.bleed < this.ai.bleed) {
+      const effectBonus = Math.round(this.player.hp * 0.1 + this.player.shield + this.player.strength * 0.5);
+      this.singleBonus += effectBonus;
+      this.singleBonusMultiplier *= 2;
+      bonusMessage += `压倒性的优势！获得${effectBonus}点分数！本回合分数*2！
+`;
+    }
+    if (effect.magnificentEnd && this.ai.bleed > 4) {
+      const effectBonus = Math.round(this.ai.bleed * 1.5);
+      this.singleBonusMultiplier *= effectBonus;
+      this.bonus *= 2;
+      bonusMessage += `华丽收场！当前总分数*2，本回合分数*${effectBonus}!
+`;
+    }
+    if (this.comboCombos >= 1) {
+      this.singleBonusMultiplier += this.comboCombos / 5;
+      bonusMessage += `组合技连击${this.comboCombos}次！本回合分数+${20 * this.comboCombos}%！`;
+    }
+    return bonusMessage;
   }
   processAiTurn(handA, handB) {
-    if (this.ai.hp <= 0) {
-      return `已经结束游戏`;
-    }
+    if (this.ai.hp <= 0)
+      return `已经结束游戏
+
+` + this.buildAiTurnBonusMessage(SKILL_MAP["-1"]);
     if (this.ai.status === 2 /* lastStunned */) {
       this.ai.status = 0 /* Normal */;
     }
     if (this.ai.status === 1 /* Stunned */) {
       this.ai.status = 2 /* lastStunned */;
       this.ai = this.applyEffectToSelf(this.player, this.ai, SKILL_MAP["-1"]);
-      return "被眩晕，跳过回合";
+      return "被眩晕，跳过回合，本回合分数奖励继承到下一回合";
     }
     const sum = (handA + handB) % 10;
     this.ai[handA === this.ai.left ? "left" : "right"] = sum;
@@ -2393,9 +2530,54 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       isCombo = true;
       effect = { ...combo };
     }
-    this.player = this.applyEffectToEnemy(this.ai, this.player, effect, !!combo);
-    this.ai = this.applyEffectToSelf(this.player, this.ai, effect);
-    return handA + "碰" + handB + "，" + this.buildResultMessage(effect, isCombo, this.ai, this.player);
+    const playerState = this.player;
+    const aiState = this.ai;
+    const bonusMessage = this.buildAiTurnBonusMessage(effect);
+    this.player = this.applyEffectToEnemy(aiState, playerState, effect, !!combo);
+    this.ai = this.applyEffectToSelf(playerState, aiState, effect);
+    return handA + "碰" + handB + "，" + this.buildResultMessage(effect, isCombo, this.ai, this.player) + (bonusMessage ? `
+
+${bonusMessage}` : "");
+  }
+  buildAiTurnBonusMessage(effect) {
+    let bonusMessage = "";
+    if ((effect.damage || effect.pierceDamage) && this.player.counterAttack > 0) {
+      const effectBonus = Math.max(this.player.counterAttack + this.player.strength, 0);
+      this.singleBonus += effectBonus;
+      bonusMessage += `反击！获得${effectBonus}点分数!
+`;
+    }
+    if ((effect.damage || 0) > 12 && this.player.shield > 0) {
+      const effectBonus = Math.round(effect.damage);
+      this.singleBonus += effectBonus;
+      bonusMessage += `关键格挡！获得${effectBonus}点分数!
+`;
+    }
+    if (this.player.shield > 0 && effect.damage && this.player.counterAttack > 0) {
+      const effectBonus = Math.round(this.player.shield * 2 + this.player.counterAttack);
+      this.singleBonus += effectBonus;
+      bonusMessage += `盾反！获得${effectBonus}点分数!
+`;
+    }
+    if (effect.damage && this.player.vulnerablility > 0 && this.player.shield > 0) {
+      const effectBonus = 0.5;
+      this.singleBonusMultiplier += effectBonus;
+      bonusMessage += `易伤保护！本回合分数增加${100 * effectBonus}%!
+`;
+    }
+    if (effect.weakStun && this.player.shield > 0) {
+      const effectBonus = 0.3;
+      this.singleBonusMultiplier += effectBonus;
+      bonusMessage += `眩晕格挡！本回合分数增加${100 * effectBonus}%!
+`;
+    }
+    const turnBonus = Math.round(this.singleBonus * this.singleBonusMultiplier);
+    this.bonus += turnBonus;
+    bonusMessage += `本回合总计获得${this.singleBonus}*${this.singleBonusMultiplier}=${turnBonus}点分数
+当前总分数：${this.bonus}`;
+    this.singleBonus = 0;
+    this.singleBonusMultiplier = 1;
+    return bonusMessage;
   }
   // damage?: number // 普通伤害
   // damageTimes?: number // 伤害次数
@@ -2433,6 +2615,8 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
         }
       }
     }
+    if (effect.revwersalOfStrength)
+      target.strength = self.strength;
     if (effect.magnificentEnd) {
       target.hp -= target.bleed * (target.bleed + 1) / 2;
       target.bleed = 0;
@@ -2463,6 +2647,8 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       self.counterAttack = effect.counterAttack;
     if (enemy.counterAttack > 0 && (effect.damage > 0 || effect.pierceDamage > 0))
       self.hp -= Math.max(enemy.counterAttack + (enemy.strength || 0), 0);
+    if (effect.revwersalOfStrength)
+      self.strength = enemy.strength;
     if (effect.selfStun && self.status !== 2 /* lastStunned */)
       self.status = 1 /* Stunned */;
     if (effect.selfbleed)
@@ -2629,8 +2815,10 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
       attacker[handA === attacker.left ? "left" : "right"] = sum;
       const combo = this.checkCombo(attacker.left, attacker.right);
       const effect = combo ? combo : SKILL_MAP[sum.toString()] || {};
-      defender = this.applyEffectToEnemy(attacker, defender, effect, !!combo);
-      attacker = this.applyEffectToSelf(defender, attacker, effect);
+      const defenderState = defender;
+      const attackerState = attacker;
+      defender = this.applyEffectToEnemy(attackerState, defenderState, effect, !!combo);
+      attacker = this.applyEffectToSelf(defenderState, attackerState, effect);
     }
     if (attackerIndex === 1) {
       const temp = attacker;
@@ -2644,13 +2832,43 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   evaluateState(state) {
     const ai = state[1];
     const player = state[0];
+    const aiBaseHP = this.baseHP + this.level * this.aiLevelHp;
+    const playerBaseHP = this.baseHP + this.level * this.playerLevelHP;
     let score = ai.hp - player.hp;
-    score += Math.min(ai.strength * 5, 50);
-    score -= Math.min(player.strength * 5, 50);
+    if (ai.hp < aiBaseHP / 2)
+      score -= Math.round(aiBaseHP / 4);
+    if (player.hp < playerBaseHP / 2)
+      score += Math.round(playerBaseHP / 4);
+    if (ai.hp < aiBaseHP / 4)
+      score -= Math.round(aiBaseHP / 4);
+    if (player.hp < playerBaseHP / 4)
+      score += Math.round(playerBaseHP / 4);
+    if (ai.hp < aiBaseHP / 8)
+      score -= Math.round(aiBaseHP / 4);
+    if (player.hp < playerBaseHP / 8)
+      score += Math.round(playerBaseHP / 4);
+    score += Math.min(ai.strength * 5, 100);
+    score -= Math.min(player.strength * 5);
+    if (ai.strength < 0)
+      score += Math.round(ai.strength * 5);
+    if (player.strength < 0)
+      score -= Math.round(player.strength * 5);
     score += ai.shield * 8;
     score -= player.shield * 8;
-    score -= Math.min(Math.round(ai.bleed * ai.bleed / 2.5), 900);
-    score += Math.min(Math.round(player.bleed * player.bleed / 2.5), 900);
+    score -= Math.min(Math.round(ai.bleed * ai.bleed / 2.5));
+    score += Math.min(Math.round(player.bleed * player.bleed / 2.5));
+    if (ai.status === 1 /* Stunned */)
+      score -= 10;
+    if (player.status === 1 /* Stunned */)
+      score += 10;
+    if (ai.counterAttack > 0)
+      score += Math.max(ai.counterAttack + (ai.strength || 0), 0);
+    if (player.counterAttack > 0)
+      score -= Math.max(player.counterAttack + (player.strength || 0), 0);
+    if (ai.vulnerablility > 0)
+      score -= Math.round(ai.vulnerablility * 4);
+    if (player.vulnerablility > 0)
+      score += Math.round(player.vulnerablility * 4);
     if (player.hp <= 0)
       score += 1e5;
     if (ai.hp <= 0)
@@ -2658,26 +2876,26 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
     return score;
   }
   generateChat(Score) {
-    if (this.lastScore < 1e5 && Score > 1e5) {
+    if (this.lastScore < 9e4 && Score > 9e4) {
       return "我觉得你要输了哦~";
     }
     if (this.lastScore < 0 && Score > 0) {
       return "局势发生变化了呢~";
     }
-    if (this.lastScore > -1e5 && Score < -1e5) {
-      return "感觉我要输了呢~";
-    }
+    if (Score - this.lastScore > 10)
+      return "看招！";
   }
   instuction = `游戏说明：
   这个游戏的基本玩法是：
   两个人玩，两只手分别可以做出"一到十"的手势，每一种手势代表一个招式。
   例如"三"是${SKILL_MAP["3"].name}，"四"是${SKILL_MAP["4"].name}等；当两只手符合特定组合时还可以触发组合技；
   每个人在自己的回合可以选择用自己的一只手碰对方的另一只手，两者数值相加，如果超过十仅保留个位。
-  例如自己的"一"碰对方的"二"变成"三"可以触发技能"${SKILL_MAP["3"].name}"对对方造成伤害。
+  例如自己的"一"碰对方的"二"变成"三"同时触发技能"${SKILL_MAP["3"].name}"对对方造成伤害。
   每次开局两人初始手势随机，由玩家先手，双方轮流行动。
+  当自身两手手势相同时，无论选择左手还是右手最终发生变化的都是左手。
   玩家初始有"${this.baseHP} + ${this.playerLevelHP} * 难度"血量。
   ai初始有"${this.baseHP} + ${this.aiLevelHp} * 难度"血量。
-  玩家初始有"难度 / 3"护盾，"难度 / 5"力量，四舍五入取整。
+  玩家初始有"难度 / 2"护盾，四舍五入取整。
   血量没有上限，率先将对方血量减到零的人获胜：
   具体的技能设计如下：{
   一：${SKILL_MAP["1"].name}：造成${SKILL_MAP["1"].pierceDamage}穿刺伤害，${SKILL_MAP["1"].bleed}流血;
@@ -2707,6 +2925,7 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   七+八：${SKILL_MAP["7+8"].name}：造成${SKILL_MAP["7+8"].pierceDamage}穿刺伤害，破坏对方${SKILL_MAP["7+8"].destroyShield}层护盾，眩晕自己
   六+二：${SKILL_MAP["2+6"].name}：造成${SKILL_MAP["2+6"].damage}伤害，恢复${SKILL_MAP["2+6"].heal}生命，自身${SKILL_MAP["2+6"].selfbleed}流血，自身增加${SKILL_MAP["2+6"].selfstrengthChange}力量，眩晕对方
   三+七：${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+0"].name}：对对方造成${SKILL_MAP["0+0"].bleed}流血，自身${SKILL_MAP["0+0"].selfstrengthChange}力量，然后立即结算对方全部流血
   }
   注：
@@ -2714,11 +2933,12 @@ var OneTouchSingleGame = class extends abstractGameSingleGame {
   护盾效果：每一层护盾可阻挡下一次受到的普通伤害，如果伤害来源是组合技则消耗两层护盾(若仅有一层则消耗一层)。护盾上限为五层。
   眩晕效果：跳过自己的下一个回合，若上回合已经被眩晕，则本回合不受眩晕影响（即不可被连续眩晕）
   弱眩晕效果：若对方没有护盾，则眩晕对方一回合
-  反击：下一回合若对方行动中有攻击，则对方受到反击层数点穿刺伤害，此效果受力量加成，且仅持续一回合
+  反击：下一回合若对方行动中有攻击，则对方攻击前受到反击层数点穿刺伤害，此效果受力量加成，且仅持续一回合
   穿刺伤害：不被护盾影响的伤害（不会消耗护盾）
   力量效果：每有一点力量，每次造成的伤害+1，若为负数则减一
   易伤效果：受到的普通伤害+50%，自己的回合结束时减少一层
   组合技：两只手势符合组合技条件时触发组合技，组合技的效果会覆盖普通技能的效果，组合无序
+  bonus: 当行动导致关键效果时，获得额外奖励，在ai回合结束时结算，若ai被眩晕则奖励继承到下一回合
   `;
 };
 var OneTouchGame = class extends abstractGame {
@@ -2734,9 +2954,9 @@ var OneTouchGame = class extends abstractGame {
       level = parseInt(args[0]);
     else {
       setTimeout(() => {
-        session.send("未输入难度等级(2-10)，默认设为5");
+        session.send("未输入难度等级(2-10)，默认设为3");
       }, 500);
-      level = 5;
+      level = 3;
     }
     if (level < 2 || level > 10) {
       level = level < 2 ? 2 : 10;
@@ -2895,20 +3115,17 @@ var Game = class {
         return;
       case "一碰一":
         const oneTouchResult = result;
-        const oneTouchLevel = parseInt(oneTouchResult.message);
-        const oneTouchBonus = Math.floor(oneTouchLevel * (Math.random() * 2 + 9));
+        const oneTouchBonus = oneTouchResult.bonus;
         if (oneTouchResult.win === 1 /* win */) {
-          updateUserP(ctx, user, oneTouchBonus * 2);
-          updateFavorability(ctx, user, oneTouchLevel * 2);
-          session.send("真厉害，奖励你" + oneTouchBonus * 2 + "p点,好感度+" + Math.round(oneTouchLevel * 0.2));
+          updateUserP(ctx, user, oneTouchBonus);
+          updateFavorability(ctx, user, Math.round(oneTouchBonus * 0.02));
+          session.send("真厉害，奖励你" + oneTouchBonus + "p点,好感度+" + Math.round(oneTouchBonus * 0.02));
         } else if (oneTouchResult.win === 2 /* lose */) {
-          updateUserP(ctx, user, -oneTouchBonus);
-          session.send("真可惜，你输了" + oneTouchBonus + "p点");
-        } else if (oneTouchResult.win === 3 /* draw */)
-          session.send("平局，稍后再战吧");
-        else {
-          updateUserP(ctx, user, -oneTouchBonus);
-          session.send("游戏中断，你输了" + oneTouchBonus + "p点");
+          updateUserP(ctx, user, oneTouchBonus);
+          session.send("真可惜，你输了" + -oneTouchBonus + "p点");
+        } else {
+          updateUserP(ctx, user, oneTouchBonus);
+          session.send("游戏中断，你输了" + -oneTouchBonus + "p点");
         }
         return;
       default:
@@ -3231,7 +3448,7 @@ var SAT = class extends Sat {
       else
         logger12.info(`Satori AI：${response.content}`);
     }
-    if (this.config.reasoner_filter)
+    if (this.config.reasoner_filter && !response.error)
       response = filterResponse(response.content, this.config.reasoner_filter_word.split("-"));
     return response;
   }

package/package.json

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