koishi-plugin-smmcat-gensokyo 0.0.21 → 0.0.23

package/lib/battle.d.ts

@@ -1,6 +1,8 @@
 import { Context, Session } from "koishi";
 import { Config } from ".";
 import { UserBaseAttribute } from "./users";
+import { UserOccupation } from "./data/skillFn";
+import { MonsterOccupation } from "./data/initMonster";
 declare module 'koishi' {
     interface Tables {
         smm_gensokyo_battle_history: BattleHistory;
@@ -32,6 +34,8 @@ export type BattleAttribute = {
     userId?: string;
     /** 类型 */
     type: '玩家' | '怪物';
+    /** 自有类型 */
+    selfType: UserOccupation | MonsterOccupation;
     /** 血量 */
     hp: number;
     /** 最大血量 */
@@ -57,33 +61,47 @@ export type BattleAttribute = {
     /** 出手速度 */
     speed: number;
     /** 临时增益状态 */
-    gain: {
-        /** 临时增益-最大血量 */
-        maxHp: number;
-        /** 临时增益-最大蓝量 */
-        maxMp: number;
-        /** 临时增益-攻击力 */
-        atk: number;
-        /** 临时增益-防御力 */
-        def: number;
-        /** 临时增益-暴击率 */
-        chr: number;
-        /** 临时增益-暴击伤害 */
-        ghd: number;
-        /** 临时增益-闪避值 */
-        evasion: number;
-        /** 临时增益-命中值 */
-        hit: number;
-        /** 临时增益-出手速度 */
-        speed: number;
-    };
+    gain: BuffGain;
     /** 滞留状态 */
     buff: {
+        [keys: string]: {
+            name: string;
+            timer: number;
+        };
+    };
+    /** 持有技能 */
+    fn?: {
         name: string;
-        time: number;
+        prob: number;
     }[];
-    /** 持有技能 */
-    fn?: [];
+    /** 拓展数据 */
+    expand: {
+        [keys: string]: any;
+    };
+};
+export type BuffGain = {
+    /** 临时增益-最大血量 */
+    maxHp?: number;
+    /** 临时增益-最大蓝量 */
+    maxMp?: number;
+    /** 临时增益-攻击力 */
+    atk?: number;
+    /** 临时增益-防御力 */
+    def?: number;
+    /** 临时增益-暴击率 */
+    chr?: number;
+    /** 临时增益-暴击伤害 */
+    ghd?: number;
+    /** 临时增益-闪避值 */
+    evasion?: number;
+    /** 临时增益-命中值 */
+    hit?: number;
+    /** 临时增益-出手速度 */
+    speed?: number;
+    /** 是否眩晕 */
+    dizziness?: boolean;
+    /** 是否混乱 */
+    chaos?: boolean;
 };
 /** 最后战斗状态 */
 type LastPlay = {
@@ -149,4 +167,8 @@ export declare const BattleData: {
 };
 /**  获取阵容角色名 */
 export declare function getLineupName(agent: BattleAttribute): string;
+export declare function getSkillFn(fnList: {
+    name: string;
+    prob: number;
+}[]): string;
 export {};

package/lib/damage.d.ts

@@ -46,10 +46,17 @@ declare class Damage {
     beforDef(fn: (config: DamageConfig) => void): this;
     result(fn?: DamageCallback): DamageConfig;
 }
+declare class BuffDamage {
+    goal: BattleAttribute;
+    val: number;
+    isRealHarm: boolean;
+    constructor(val: number, goal: BattleAttribute, isRealHarm?: boolean);
+    giveDamage(): number;
+}
 /** 给予目标伤害 */
 declare function giveDamage(self: BattleAttribute, goal: BattleAttribute, damage: DamageConfig): number;
 /** 治疗目标 */
 declare function giveCure(goal: BattleAttribute, val: number): number;
 /** 伤害额外信息 */
 export declare function moreDamageInfo(damage: DamageConfig): string;
-export { Damage, giveDamage, giveCure };
+export { Damage, BuffDamage, giveDamage, giveCure };

package/lib/data/buffFn.d.ts

@@ -0,0 +1,59 @@
+import { BattleAttribute, BuffGain } from "../battle";
+export declare enum BuffType {
+    增益 = "\u589E\u76CA",
+    减益 = "\u51CF\u76CA",
+    印记 = "\u5370\u8BB0",
+    控制 = "\u63A7\u5236",
+    伤害 = "\u4F24\u5BB3",
+    治疗 = "\u6CBB\u7597"
+}
+interface BuffParams {
+    type: BuffType.增益;
+    up: BuffGain;
+}
+interface DeBuffParams {
+    type: BuffType.减益;
+    down: BuffGain;
+}
+interface ImprintBuffParams {
+    type: BuffType.印记;
+    key: string;
+    data: any;
+}
+interface ControlBuffParams {
+    type: BuffType.控制;
+    name: '晕眩' | '控制';
+}
+interface TreatmentBuffParams {
+    type: BuffType.治疗;
+    val: number;
+}
+interface HarmBuffParams {
+    type: BuffType.伤害;
+    val: number;
+    isRealHarm?: boolean;
+}
+type BuffItemParams = BuffParams | DeBuffParams | ImprintBuffParams | ControlBuffParams | TreatmentBuffParams | HarmBuffParams;
+interface BuffConfig<T extends BuffType = BuffType> {
+    /** 被动名 */
+    name: string;
+    /** 被动类型 */
+    type: T;
+    /** 被动说明 */
+    info: string;
+    /** 被动函数 */
+    fn(agent: BattleAttribute, cb?: (val: Extract<BuffItemParams, {
+        type: T;
+    }>) => void): void;
+}
+type BuffFnList = {
+    [key: string]: BuffConfig;
+};
+export declare const BuffFn: BuffFnList;
+/** 为目标添加BUFF */
+export declare function giveBuff(agent: BattleAttribute, buff: {
+    name: string;
+    timer: number;
+}): string;
+export declare function settlementBuff(agent: BattleAttribute): string;
+export {};

package/lib/data/initMonster.d.ts

@@ -54,6 +54,12 @@ export type MonsterBaseAttribute = {
         /** 怪物等级要求？ */
         lv?: number;
     }[];
+    fn?: {
+        /** 技能名 */
+        name: string;
+        /** 触发概率 */
+        prob: number;
+    }[];
 };
 export type MonsterTempData = {
     [keys: string]: MonsterBaseAttribute;

package/lib/data/skillFn.d.ts

@@ -0,0 +1,82 @@
+import { BattleAttribute } from "../battle";
+import { DamageConfig } from "../damage";
+export declare enum SkillType {
+    释放失败 = "\u91CA\u653E\u5931\u8D25",
+    伤害技 = "\u4F24\u5BB3\u6280",
+    增益技 = "\u589E\u76CA\u6280",
+    治疗技 = "\u6CBB\u7597\u6280",
+    奥义 = "\u5965\u4E49"
+}
+export declare enum UserOccupation {
+    剑士 = "\u5251\u58EB",
+    法师 = "\u6CD5\u5E08",
+    刺客 = "\u523A\u5BA2"
+}
+interface DamageSkillParams {
+    /** 伤害类型 */
+    type: SkillType.伤害技;
+    /** 伤害信息 */
+    damage: DamageConfig;
+    /** 释放目标 */
+    target: BattleAttribute[];
+    /** 是否衔接普攻 */
+    isNext: boolean;
+}
+interface HealSkillParams {
+    type: SkillType.治疗技;
+    /** 是否衔接普攻 */
+    isNext: boolean;
+    /** 治疗量 */
+    value: number;
+    target: BattleAttribute[];
+}
+interface BuffSkillParams {
+    type: SkillType.增益技;
+    /** 是否衔接普攻 */
+    isNext: boolean;
+    /** 错误提示 */
+    err?: string;
+}
+interface UltimateSkillParams {
+    type: SkillType.奥义;
+    /** 是否衔接普攻 */
+    isNext: boolean;
+}
+interface ErrSkillParams {
+    type: SkillType.释放失败;
+    /** 是否衔接普攻 */
+    isNext: boolean;
+    /** 错误提示 */
+    err?: string;
+}
+type SkillParams = DamageSkillParams | BuffSkillParams | HealSkillParams | UltimateSkillParams | ErrSkillParams;
+interface SkillConfig<T extends SkillType = SkillType> {
+    /** 技能名 */
+    name: string;
+    /** 技能类型 */
+    type: T;
+    /** 技能说明 */
+    info: string;
+    /** 等级限制 */
+    lv: number;
+    /** 消耗MP */
+    mp: number;
+    /** 职业专属 */
+    feature?: UserOccupation[];
+    /** 技能函数 */
+    fn(agent: {
+        self: BattleAttribute;
+        goal: BattleAttribute;
+    }, agentList: {
+        selfList: BattleAttribute[];
+        goalList: BattleAttribute[];
+    }, cb?: (val: Extract<SkillParams, {
+        type: T;
+    }>) => void): string;
+}
+type SkillFn = {
+    [key: string]: SkillConfig;
+};
+export type UseAtkType = keyof typeof skillFn | '普攻';
+export declare const skillFn: SkillFn;
+export {};

package/lib/index.js

@@ -376,7 +376,7 @@ var monsterBenchmark = {
     def: 1.1,
     chr: 1.1,
     evasion: 1.1,
-    hit: 1.1,
+    hit: 1.08,
     ghd: 1,
     speed: 1.05
   },
@@ -389,7 +389,7 @@ var monsterBenchmark = {
     def: 1.1,
     chr: 1.08,
     evasion: 1.08,
-    hit: 1.08,
+    hit: 1.06,
     ghd: 1,
     speed: 1.05
   },
@@ -402,7 +402,7 @@ var monsterBenchmark = {
     def: 1.05,
     chr: 1.05,
     evasion: 1.05,
-    hit: 1.05,
+    hit: 1.04,
     ghd: 1.05,
     speed: 1.05
   }
@@ -472,7 +472,8 @@ var monsterData = {
     giveMonetary: 2,
     giveProps: [
       { name: "红药", val: 3, radomVal: 30 }
-    ]
+    ],
+    fn: [{ name: "垂死挣扎", prob: 1 }]
   },
   "小蜘蛛": {
     name: "小蜘蛛",
@@ -504,8 +505,8 @@ var monsterData = {
     pic: "http://smmcat.cn/run/gensokyo/dora.png",
     hp: 88,
     maxHp: 88,
-    mp: 10,
-    maxMp: 10,
+    mp: 30,
+    maxMp: 30,
     atk: 20,
     def: 5,
     chr: 200,
@@ -519,7 +520,8 @@ var monsterData = {
     giveProps: [
       { name: "蓝药", val: 3, radomVal: 30 },
       { name: "初级万能药", val: 2, radomVal: 90, const: true, lv: 5 }
-    ]
+    ],
+    fn: [{ name: "治愈之光", prob: 1 }]
   },
   "琪露诺": {
     name: "琪露诺",
@@ -588,7 +590,8 @@ var monsterData = {
     giveMonetary: 5,
     giveProps: [
       { name: "初级复活卷轴", val: 1, radomVal: 50 }
-    ]
+    ],
+    fn: [{ name: "初级治愈", prob: 3 }, { name: "水炮", prob: 1 }]
   }
 };
 
@@ -791,6 +794,31 @@ var Damage = class {
     return this.config;
   }
 };
+var BuffDamage = class {
+  static {
+    __name(this, "BuffDamage");
+  }
+  goal;
+  val;
+  isRealHarm;
+  constructor(val, goal, isRealHarm = false) {
+    this.goal = goal;
+    this.val = val;
+    this.isRealHarm = isRealHarm;
+  }
+  giveDamage() {
+    if (this.isRealHarm) {
+      const val = this.goal.hp - this.val > 0 ? this.val : this.goal.hp;
+      this.goal.hp -= val;
+      return val;
+    } else {
+      const def = this.goal.def + this.goal.gain.def;
+      const val = this.goal.hp + def - this.val > 0 ? this.val - def : this.goal.hp;
+      this.goal.hp -= val;
+      return val;
+    }
+  }
+};
 function giveDamage(self, goal, damage) {
   if (goal.hp - damage.harm > 0) {
     goal.hp -= damage.harm;
@@ -819,7 +847,185 @@ function moreDamageInfo(damage) {
 }
 __name(moreDamageInfo, "moreDamageInfo");
 
-// src/skillFn.ts
+// src/data/buffFn.ts
+var BuffFn = {
+  "治愈": {
+    name: "治愈",
+    type: "治疗" /* 治疗 */,
+    info: "每回合回复5%最大血量（最低回复1血）",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      if (agent.hp <= 0) return;
+      const val = Math.floor((agent.maxHp + agent.gain.maxHp) * 0.05) || 1;
+      fn && fn({
+        type: "治疗" /* 治疗 */,
+        val
+      });
+    }, "fn")
+  },
+  "中毒": {
+    name: "中毒",
+    type: "伤害" /* 伤害 */,
+    info: "自身每回合受到5%最大血量伤害的真实伤害（最低扣除1血，最高20血）",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      if (agent.hp <= 0) return;
+      const val = Math.min(20, Math.floor((agent.maxHp + agent.gain.maxHp) * 0.05) || 1);
+      fn && fn({
+        type: "伤害" /* 伤害 */,
+        val,
+        isRealHarm: true
+      });
+    }, "fn")
+  },
+  "晕眩": {
+    name: "晕眩",
+    type: "控制" /* 控制 */,
+    info: "该回合将无法行动",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      fn && fn({
+        type: "控制" /* 控制 */,
+        name: this.name
+      });
+    }, "fn")
+  },
+  "混乱": {
+    name: "混乱",
+    type: "控制" /* 控制 */,
+    info: "该回合将无法行动",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      fn && fn({
+        type: "控制" /* 控制 */,
+        name: this.name
+      });
+    }, "fn")
+  },
+  "强壮": {
+    name: "强壮",
+    type: "增益" /* 增益 */,
+    info: "提高基于自身攻击力10%的临时攻击力，最低1点攻击力",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      const val = Math.floor(agent.atk * 0.1);
+      fn && fn({
+        type: "增益" /* 增益 */,
+        up: {
+          atk: val
+        }
+      });
+    }, "fn")
+  },
+  "弱化": {
+    name: "弱化",
+    type: "减益" /* 减益 */,
+    info: "削弱基于自身攻击力10%，但攻击力最低为1点",
+    fn: /* @__PURE__ */ __name(function(agent, fn) {
+      const val = Math.floor(agent.atk * 0.1);
+      fn && fn({
+        type: "减益" /* 减益 */,
+        down: {
+          atk: val
+        }
+      });
+    }, "fn")
+  }
+};
+function giveBuff(agent, buff) {
+  const buffInfo = BuffFn[buff.name] || null;
+  if (!buffInfo) return;
+  let again = false;
+  if (agent.buff[buff.name]) again = true;
+  agent.buff[buff.name] = buff;
+  const dict = { 1: "¹", 2: "²", 3: "³", 4: "⁴", 5: "⁵", 6: "⁶", 7: "⁷", 8: "⁸", 9: "⁹" };
+  return `${getLineupName(agent)}被挂上了${buff.name}${dict[buff.timer] || "⁺"}`;
+}
+__name(giveBuff, "giveBuff");
+function settlementBuff(agent) {
+  if (agent.hp <= 0) return null;
+  agent.gain.atk = 0;
+  agent.gain.chr = 0;
+  agent.gain.def = 0;
+  agent.gain.evasion = 0;
+  agent.gain.ghd = 0;
+  agent.gain.hit = 0;
+  agent.gain.maxHp = 0;
+  agent.gain.maxMp = 0;
+  agent.gain.maxMp = 0;
+  agent.gain.speed = 0;
+  agent.gain.dizziness = false;
+  agent.gain.chaos = false;
+  const msgList = [];
+  const gainDict = {
+    atk: "攻击",
+    def: "防御",
+    maxHp: "最大生命值",
+    maxMp: "最大魔法值",
+    chr: "暴击率",
+    ghd: "暴击伤害",
+    evasion: "闪避值",
+    hit: "命中值",
+    speed: "速度"
+  };
+  Object.keys(agent.buff).forEach((item) => {
+    const buffInfo = BuffFn[item] || null;
+    if (!buffInfo) return;
+    switch (buffInfo.type) {
+      case "伤害" /* 伤害 */:
+        buffInfo.fn(agent, (val) => {
+          const value = new BuffDamage(val.val, agent, val.isRealHarm).giveDamage();
+          msgList.push(`${buffInfo.name}-${value}HP`);
+        });
+        break;
+      case "治疗" /* 治疗 */:
+        buffInfo.fn(agent, (val) => {
+          const value = giveCure(agent, val.val);
+          msgList.push(`${buffInfo.name}+${value}HP`);
+        });
+        break;
+      case "增益" /* 增益 */:
+        const upMsg = [];
+        buffInfo.fn(agent, (val) => {
+          Object.keys(val.up).forEach((buffName) => {
+            if (agent.gain[buffName]) {
+              upMsg.push(
+                val.up[buffName] > 0 ? gainDict[buffName] + "↑" + val.up[buffName] : gainDict[buffName] + "↓" + Math.abs(val.up[buffName])
+              );
+              agent.gain[buffName] += val.up[buffName];
+            }
+          });
+          msgList.push(`${buffInfo.name}:${upMsg.join("、")}`);
+        });
+        break;
+      case "减益" /* 减益 */:
+        const downMsg = [];
+        buffInfo.fn(agent, (val) => {
+          Object.keys(val.down).forEach((buffName) => {
+            if (agent.gain[buffName]) {
+              downMsg.push(
+                val.down[buffName] > 0 ? gainDict[buffName] + "↓" + val.down[buffName] : gainDict[buffName] + "↑" + Math.abs(val.down[buffName])
+              );
+              agent.gain[buffName] -= val.down[buffName];
+            }
+          });
+          msgList.push(`${buffInfo.name}:${upMsg.join("、")}`);
+        });
+        break;
+      case "控制" /* 控制 */:
+        buffInfo.fn(agent, (val) => {
+          const control = { "晕眩": "dizziness", "控制": "chaos" };
+          if (!control[val.name]) return;
+          agent.gain[control[val.name]] = true;
+          return `当前正在${val.name}中...`;
+        });
+        break;
+      default:
+        break;
+    }
+    --agent.buff[item].timer;
+    if (agent.buff[item].timer == 0) delete agent.buff[item];
+  });
+  return msgList.length ? msgList.map((item) => `» ${getLineupName(agent)}:${item})`).join("\n") : null;
+}
+__name(settlementBuff, "settlementBuff");
+
+// src/data/skillFn.ts
 var skillFn = {
   "重砍": {
     name: "重砍",
@@ -939,6 +1145,42 @@ var skillFn = {
       });
       return `${getLineupName(agent.self)}释放初级治愈，${getLineupName(agent.goal)}恢复40HP`;
     }, "fn")
+  },
+  "垂死挣扎": {
+    name: "垂死挣扎",
+    type: "伤害技" /* 伤害技 */,
+    info: "对目标造成1.5倍伤害",
+    lv: 1,
+    mp: 20,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      const damageData = new Damage(agent).result({
+        before: /* @__PURE__ */ __name((val) => {
+          val.default_harm += Math.floor(val.default_harm * 0.5);
+        }, "before")
+      });
+      fn({
+        damage: damageData,
+        type: this.type,
+        target: [agent.goal],
+        isNext: false
+      });
+      return `${getLineupName(agent.self)} 进行垂死挣扎，对 ${getLineupName(agent.goal)} 造成 ${damageData.harm} 伤害。` + moreDamageInfo(damageData);
+    }, "fn")
+  },
+  "治愈之光": {
+    name: "治愈之光",
+    type: "增益技" /* 增益技 */,
+    info: "为目标挂上3回合治愈状态",
+    lv: 1,
+    mp: 20,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      giveBuff(agent.goal, { name: "治愈", timer: 3 });
+      fn({
+        type: "增益技" /* 增益技 */,
+        isNext: true
+      });
+      return `${getLineupName(agent.self)} 对 ${getLineupName(agent.goal)} 释放治愈之光。`;
+    }, "fn")
   }
 };
 
@@ -1075,9 +1317,16 @@ var BattleData = {
   battleSituationTextFormat(team) {
     const selfTemp = [];
     const goalTemp = [];
+    const getBuffTemplate = /* @__PURE__ */ __name((agent) => {
+      const dict = { 1: "¹", 2: "²", 3: "³", 4: "⁴", 5: "⁵", 6: "⁶", 7: "⁷", 8: "⁸", 9: "⁹" };
+      const buffInfo = Object.keys(agent.buff).map((item) => {
+        return `${agent.buff[item].name}${dict[agent.buff[item].timer] || "⁺"}`;
+      });
+      return buffInfo.length ? "(" + buffInfo.join(" ") + ")" : "";
+    }, "getBuffTemplate");
     team.self.forEach((item) => {
       if (item.hp > 0) {
-        selfTemp.push(`lv.${item.lv}[${item.name}]:
+        selfTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
 ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
 MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
@@ -1086,7 +1335,7 @@ MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
     });
     team.goal.forEach((item) => {
       if (item.hp > 0) {
-        goalTemp.push(`lv.${item.lv}[${item.name}]:
+        goalTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
 ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
 MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
@@ -1134,6 +1383,8 @@ MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
     const allAgentList = [...currentBattle.goal, ...currentBattle.self].sort((a, b) => b.speed - a.speed);
     const msgList = [];
     for (const agent of allAgentList) {
+      const buffMsg = settlementBuff(agent);
+      buffMsg && msgList.push(buffMsg);
       if (agent.hp <= 0) {
         if (agent.type == "玩家" && !User.userTempData[agent.userId]?.isDie) {
           User.userTempData[agent.userId].hp = 0;
@@ -1141,78 +1392,93 @@ MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
         }
         continue;
       }
-      let lifeGoalList = [];
-      let lifeSelfList = [];
-      if (agent.for == "self") {
-        lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
-        lifeSelfList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
-      } else {
-        lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
-        lifeSelfList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
-      }
-      if (!lifeGoalList.length) continue;
-      let selectGoal = {};
-      let isMy = false;
-      let funType = "普攻";
-      if (agent.type == "玩家" && agent.userId == session.userId) {
-        isMy = true;
-        funType = atkType;
-        selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-      } else if (agent.type == "玩家") {
-        selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-      } else {
-        selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-      }
-      const noralAtk = /* @__PURE__ */ __name(() => {
-        const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
-        giveDamage(agent, selectGoal, damageInfo);
-        msgList.push(
-          `${getLineupName(agent)} 使用普攻攻击了 ${getLineupName(selectGoal)}，造成了${damageInfo.harm}伤害。` + moreDamageInfo(damageInfo)
-        );
-      }, "noralAtk");
-      if (funType == "普攻") {
-        noralAtk();
-      } else {
-        if (skillFn[atkType]) {
-          if (["治疗技" /* 治疗技 */, "增益技" /* 增益技 */].includes(skillFn[atkType].type)) {
-            selectGoal = lifeSelfList.find((item) => item.name == select) || agent;
+      if (!agent.gain.dizziness) {
+        let lifeGoalList = [];
+        let lifeSelfList = [];
+        if (agent.for == "self") {
+          lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+          lifeSelfList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+        } else {
+          lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+          lifeSelfList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+        }
+        if (!lifeGoalList.length) continue;
+        let selectGoal = {};
+        let isMy = false;
+        let funType = "普攻";
+        if (!agent.gain.chaos) {
+          if (agent.type == "玩家" && agent.userId == session.userId) {
+            isMy = true;
+            funType = atkType;
+            selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+          } else if (agent.type == "玩家") {
+            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+          } else {
+            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+            if (random(0, 10) < 4 && agent.fn?.length) {
+              funType = getSkillFn(agent.fn);
+            }
           }
-          const selectFn = skillFn[atkType];
-          if (selectFn.mp == 0 || agent.mp - selectFn.mp >= 0) {
-            agent.mp -= selectFn.mp;
-            let isNext = false;
-            const fnMsg = selectFn.fn(
-              { self: agent, goal: selectGoal },
-              { selfList: lifeSelfList, goalList: lifeGoalList },
-              (val) => {
-                switch (val.type) {
-                  case "伤害技" /* 伤害技 */:
-                    val.target.map((goal) => {
-                      giveDamage(agent, goal, val.damage);
-                    });
-                    break;
-                  case "治疗技" /* 治疗技 */:
-                    val.target.map((goal) => {
-                      giveCure(goal, val.value);
-                    });
-                    break;
-                  case "释放失败" /* 释放失败 */:
-                    val.err && session.send(val.err);
-                  default:
-                    break;
+        } else {
+          const fliteMyList = allAgentList.filter((item) => item.name !== agent.name && item.hp > 0);
+          if (!fliteMyList.length) continue;
+          selectGoal = fliteMyList[Math.random() * fliteMyList.length];
+        }
+        const noralAtk = /* @__PURE__ */ __name(() => {
+          const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
+          giveDamage(agent, selectGoal, damageInfo);
+          msgList.push(
+            `${getLineupName(agent)} 使用普攻攻击了 ${getLineupName(selectGoal)}，造成了${damageInfo.harm}伤害。` + moreDamageInfo(damageInfo)
+          );
+        }, "noralAtk");
+        if (funType == "普攻") {
+          noralAtk();
+        } else {
+          if (skillFn[funType]) {
+            let _selectGoal = selectGoal;
+            if (["治疗技" /* 治疗技 */, "增益技" /* 增益技 */].includes(skillFn[funType].type)) {
+              _selectGoal = lifeSelfList.find((item) => item.name == select) || agent;
+            }
+            const selectFn = skillFn[funType];
+            if (selectFn.mp == 0 || agent.mp - selectFn.mp >= 0) {
+              agent.mp -= selectFn.mp;
+              let isNext = false;
+              const fnMsg = selectFn.fn(
+                { self: agent, goal: _selectGoal },
+                { selfList: lifeSelfList, goalList: lifeGoalList },
+                (val) => {
+                  switch (val.type) {
+                    case "伤害技" /* 伤害技 */:
+                      val.target.map((goal) => {
+                        giveDamage(agent, goal, val.damage);
+                      });
+                      break;
+                    case "治疗技" /* 治疗技 */:
+                      val.target.map((goal) => {
+                        giveCure(goal, val.value);
+                      });
+                      break;
+                    case "增益技" /* 增益技 */:
+                      isMy && val.err && session.send(val.err);
+                      break;
+                    case "释放失败" /* 释放失败 */:
+                      isMy && val.err && session.send(val.err);
+                    default:
+                      break;
+                  }
+                  isNext = val.isNext;
                 }
-                isNext = val.isNext;
-              }
-            );
-            fnMsg && msgList.push(fnMsg);
-            isNext && noralAtk();
+              );
+              fnMsg && msgList.push(fnMsg);
+              isNext && noralAtk();
+            } else {
+              isMy && await session.send(`MP不足，释放失败！`);
+              noralAtk();
+            }
           } else {
-            await session.send(`MP不足，释放失败！`);
+            isMy && await session.send(`未持有该技能或者该技能不存在，释放失败！`);
             noralAtk();
           }
-        } else {
-          await session.send(`未持有该技能或者该技能不存在，释放失败！`);
-          noralAtk();
         }
       }
     }
@@ -1312,6 +1578,19 @@ function getLineupName(agent) {
   return `[${agent.type}]${agent.name}`;
 }
 __name(getLineupName, "getLineupName");
+function getSkillFn(fnList) {
+  const totalProb = fnList.reduce((sum, item) => sum + item.prob, 0);
+  const random2 = Math.random() * totalProb;
+  let currentProb = 0;
+  for (const item of fnList) {
+    currentProb += item.prob;
+    if (random2 < currentProb) {
+      return item.name;
+    }
+  }
+  return fnList[fnList.length - 1].name;
+}
+__name(getSkillFn, "getSkillFn");
 function initBattleAttribute(data) {
   if ("playName" in data) {
     const userData = data;
@@ -1320,6 +1599,7 @@ function initBattleAttribute(data) {
       name: userData.playName,
       lv: userData.lv,
       type: "玩家",
+      selfType: userData.type,
       hp: userData.hp,
       maxHp: userData.maxHp,
       mp: userData.mp,
@@ -1341,10 +1621,13 @@ function initBattleAttribute(data) {
         ghd: 0,
         evasion: 0,
         hit: 0,
-        speed: 0
+        speed: 0,
+        chaos: false,
+        dizziness: false
       },
-      buff: [],
-      fn: []
+      buff: {},
+      fn: [],
+      expand: {}
     };
     return temp;
   } else {
@@ -1352,6 +1635,7 @@ function initBattleAttribute(data) {
     const temp = {
       name: monsterData2.name,
       type: "怪物",
+      selfType: monsterData2.type,
       lv: monsterData2.lv,
       hp: monsterData2.hp,
       maxHp: monsterData2.maxHp,
@@ -1374,10 +1658,13 @@ function initBattleAttribute(data) {
         ghd: 0,
         evasion: 0,
         hit: 0,
-        speed: 0
+        speed: 0,
+        chaos: false,
+        dizziness: false
       },
-      buff: [],
-      fn: []
+      buff: {},
+      fn: monsterData2.fn ? JSON.parse(JSON.stringify(monsterData2.fn)) : [],
+      expand: {}
     };
     return temp;
   }
@@ -1717,7 +2004,11 @@ var User = {
       await session.send("名字重复，请更换一个名字。");
       return;
     }
-    if (playname.trim().length > 6 || playname.trim().length < 1) {
+    if (Object.keys(monsterData).includes(playname?.trim())) {
+      await session.send("请不要设置怪物的名字！");
+      return;
+    }
+    if (playname.trim().length < 6 || playname.trim().length > 1) {
       await session.send("名字长度有问题，要求小于 6个字，大于 1个字");
       return;
     }

package/lib/test.d.ts

@@ -1,13 +1,8 @@
-declare const nameList: {
-    readonly 张三: {
-        readonly age: 25;
-    };
-    readonly 李四: {
-        readonly age: 30;
-    };
-};
-declare const fn: (name: keyof typeof nameList) => {
-    readonly age: 25;
-} | {
-    readonly age: 30;
-};
+declare const fn: {
+    name: string;
+    prob: number;
+}[];
+declare function useAtkFn(fnList: {
+    name: string;
+    prob: number;
+}[]): string;

package/lib/users.d.ts

@@ -1,6 +1,6 @@
 import { Context, Session } from "koishi";
 import { Config } from ".";
-import { UserOccupation } from "./skillFn";
+import { UserOccupation } from "./data/skillFn";
 declare module 'koishi' {
     interface Tables {
         smm_gensokyo_user_attribute: DatabaseUserAttribute;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-smmcat-gensokyo",
   "description": "名为《幻想乡》的文字冒险游戏",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [