koishi-plugin-smmcat-gensokyo 0.0.4 → 0.0.6

package/lib/battle.d.ts

@@ -82,6 +82,8 @@ export type BattleAttribute = {
         name: string;
         time: number;
     }[];
+    /** 持有技能 */
+    fn?: [];
 };
 /** 最后战斗状态 */
 type LastPlay = {
@@ -129,9 +131,22 @@ export declare const BattleData: {
     }): {
         over: boolean;
         type: string;
+        win: string;
     };
     /** 清理战场 */
     clearBattleData(session: Session): void;
-    play(session: Session, atkType: "\u666E\u653B", select?: string): Promise<void>;
+    play(session: Session, atkType: string, select?: string): Promise<void>;
+    /** 结算奖励 */
+    settlement(tempData: {
+        self: BattleAttribute[];
+        goal: BattleAttribute[];
+        isPK?: boolean;
+    }, overInfo: {
+        over: boolean;
+        type: string;
+        win: string;
+    }, session: Session): Promise<void>;
 };
+/**  获取阵容角色名 */
+export declare function getLineupName(agent: BattleAttribute): string;
 export {};

package/lib/damage.d.ts

@@ -10,7 +10,7 @@ type DamageCallback = {
 interface Callback {
     (data: DamageConfig): void;
 }
-type DamageConfig = {
+export type DamageConfig = {
     agent: {
         self: BattleAttribute;
         goal: BattleAttribute;
@@ -48,4 +48,8 @@ declare class Damage {
 }
 /** 给予目标伤害 */
 declare function giveDamage(self: BattleAttribute, goal: BattleAttribute, damage: DamageConfig): number;
-export { Damage, giveDamage };
+/** 治疗目标 */
+declare function giveCure(goal: BattleAttribute, val: number): number;
+/** 伤害额外信息 */
+export declare function moreDamageInfo(damage: DamageConfig): string;
+export { Damage, giveDamage, giveCure };

package/lib/data/initMonster.d.ts

@@ -0,0 +1,57 @@
+export declare enum MonsterOccupation {
+    野怪 = "\u91CE\u602A",
+    BOSS = "BOSS"
+}
+export declare const monsterData: {
+    小蜜蜂: {
+        name: string;
+        type: MonsterOccupation;
+        info: string;
+        hp: number;
+        maxHp: number;
+        mp: number;
+        maxMp: number;
+        atk: number;
+        def: number;
+        chr: number;
+        evasion: number;
+        hit: number;
+        ghd: number;
+        speed: number;
+        giveExp: number;
+    };
+    小蜘蛛: {
+        name: string;
+        type: MonsterOccupation;
+        info: string;
+        hp: number;
+        maxHp: number;
+        mp: number;
+        maxMp: number;
+        atk: number;
+        def: number;
+        chr: number;
+        evasion: number;
+        hit: number;
+        ghd: number;
+        speed: number;
+        giveExp: number;
+    };
+    dora: {
+        name: string;
+        type: MonsterOccupation;
+        info: string;
+        hp: number;
+        maxHp: number;
+        mp: number;
+        maxMp: number;
+        atk: number;
+        def: number;
+        chr: number;
+        evasion: number;
+        hit: number;
+        ghd: number;
+        speed: number;
+        giveExp: number;
+    };
+};

package/lib/index.js

@@ -601,6 +601,103 @@ ${Object.keys(UserOccDict).map((i) => `【${i}】:${UserOccDict[i].info}`).join(
 【闪避值】${temp.evasion} (+0)
 【暴击率】${(temp.chr / 10).toFixed(1)}% (+0%)
 【暴击伤害】${(temp.ghd * 100).toFixed(1)}% (+0%)`;
+  },
+  /** 写入用户数据到数据库 */
+  async setDatabaseUserAttribute(userId) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    const temp = {
+      playName: userInfo.playName.trim(),
+      hp: userInfo.hp,
+      pp: userInfo.pp,
+      mp: userInfo.mp,
+      lv: userInfo.lv,
+      exp: userInfo.exp
+    };
+    User.ctx.database.set("smm_gensokyo_user_attribute", { userId }, temp);
+  },
+  /** 给予玩家经验 */
+  async giveExp(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    const beforData = { ...User.getUserAttributeByUserId(userId) };
+    let isUp = false;
+    userInfo.exp += value;
+    while (true) {
+      const { maxExp } = User.getUserAttributeByUserId(userId);
+      if (userInfo.exp < maxExp) break;
+      userInfo.lv += 1;
+      userInfo.exp -= maxExp;
+      isUp = true;
+    }
+    if (isUp) {
+      const afterData = User.getUserAttributeByUserId(userId);
+      const upTemp = {
+        name: afterData.playName,
+        lv: afterData.lv,
+        maxHp: afterData.maxHp - beforData.maxHp,
+        maxMp: afterData.maxMp = beforData.maxMp,
+        atk: afterData.atk - beforData.atk,
+        def: afterData.def - beforData.def
+      };
+      fn && await fn(upTemp);
+    }
+    await User.setDatabaseUserAttribute(userId);
+  }
+};
+
+// src/data/initMonster.ts
+var monsterData = {
+  "小蜜蜂": {
+    name: "小蜜蜂",
+    type: "野怪" /* 野怪 */,
+    info: "幻想乡一层常见的生物",
+    hp: 50,
+    maxHp: 50,
+    mp: 30,
+    maxMp: 30,
+    atk: 7,
+    def: 2,
+    chr: 50,
+    evasion: 100,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 10
+  },
+  "小蜘蛛": {
+    name: "小蜘蛛",
+    type: "野怪" /* 野怪 */,
+    info: "幻想乡一层常见的生物",
+    hp: 55,
+    maxHp: 55,
+    mp: 30,
+    maxMp: 30,
+    atk: 10,
+    def: 3,
+    chr: 50,
+    evasion: 200,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 12
+  },
+  "dora": {
+    name: "dora",
+    type: "野怪" /* 野怪 */,
+    info: "偶尔出没在一层世界的奇怪生物",
+    hp: 88,
+    maxHp: 88,
+    mp: 10,
+    maxMp: 10,
+    atk: 20,
+    def: 5,
+    chr: 200,
+    evasion: 300,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 15
   }
 };
 
@@ -636,12 +733,12 @@ var Monster = {
         autoInc: false
       }
     );
-    const monsterData = await ctx.database.get("smm_gensokyo_monster_attribute", {});
-    if (monsterData.length == 0) {
+    const monsterData2 = await ctx.database.get("smm_gensokyo_monster_attribute", {});
+    if (monsterData2.length == 0) {
       Monster.monsterTempData = Monster._createInitMonsterData();
     } else {
       const temp = {};
-      monsterData.forEach((item) => {
+      monsterData2.forEach((item) => {
         temp[item.id] = item;
       });
       Monster.monsterTempData = temp;
@@ -649,56 +746,6 @@ var Monster = {
   },
   /** 赋予原始的怪物数据 */
   _createInitMonsterData() {
-    const monsterData = {
-      "小蜜蜂": {
-        name: "小蜜蜂",
-        type: "野怪" /* 野怪 */,
-        info: "幻想乡一层常见的生物",
-        hp: 50,
-        maxHp: 50,
-        mp: 30,
-        maxMp: 30,
-        atk: 7,
-        def: 2,
-        chr: 50,
-        evasion: 100,
-        hit: 1e3,
-        ghd: 1.2,
-        speed: 4
-      },
-      "小蜘蛛": {
-        name: "小蜘蛛",
-        type: "野怪" /* 野怪 */,
-        info: "幻想乡一层常见的生物",
-        hp: 55,
-        maxHp: 55,
-        mp: 30,
-        maxMp: 30,
-        atk: 10,
-        def: 3,
-        chr: 50,
-        evasion: 200,
-        hit: 1e3,
-        ghd: 1.2,
-        speed: 4
-      },
-      "dora": {
-        name: "dora",
-        type: "野怪" /* 野怪 */,
-        info: "偶尔出没在一层世界的奇怪生物",
-        hp: 88,
-        maxHp: 88,
-        mp: 10,
-        maxMp: 10,
-        atk: 20,
-        def: 5,
-        chr: 200,
-        evasion: 300,
-        hit: 1e3,
-        ghd: 1.2,
-        speed: 4
-      }
-    };
     return monsterData;
   },
   getMonsterAttributeData(monsterName, lv) {
@@ -800,7 +847,7 @@ var Damage = class {
     this.config = {
       agent: { self: { ...agent.self }, goal: { ...agent.goal } },
       harm: 0,
-      default_harm: agent.self.atk + agent.self.gain.atk,
+      default_harm: 0,
       isRealHarm: realHarm,
       isEvasion: false,
       isCsp: false,
@@ -809,13 +856,14 @@ var Damage = class {
   }
   /** 伤害判定前 */
   before(fn) {
+    this.config.default_harm = this.config.agent.self.atk + this.config.agent.self.gain.atk;
     fn && fn(this.config);
     return this;
   }
   /** 真实伤害判定 */
   beforRealHarm(fn) {
     fn && fn(this.config);
-    if (this.config.isEvasion) {
+    if (this.config.isRealHarm) {
       this.config.harm = this.config.default_harm;
     }
     return this;
@@ -825,7 +873,7 @@ var Damage = class {
     const { self, goal } = this.config.agent;
     if (this.config.isRealHarm) return this;
     const lvSup = /* @__PURE__ */ __name(() => Math.floor((goal.lv - self.lv) / 5) * 20, "lvSup");
-    const evaVal = Math.min(95, (goal.evasion - (self.hit - 1e3) + lvSup()) / 10);
+    const evaVal = Math.min(95, (goal.evasion + goal.gain.evasion - (self.hit - 1e3) + lvSup()) / 10);
     if (random(0, 100) <= evaVal) {
       this.config.isEvasion = true;
       fn && fn(this.config);
@@ -839,10 +887,10 @@ var Damage = class {
     const { self, goal } = this.config.agent;
     if (this.config.isRealHarm) return this;
     if (this.config.isEvasion) return this;
-    const cspVal = (self.chr - goal.csr) / 10;
+    const cspVal = (self.chr + self.gain.chr - goal.csr) / 10;
     if (random(0, 100) <= cspVal) {
       this.config.isCsp = true;
-      this.config.harm = Math.floor(this.config.default_harm * self.ghd);
+      this.config.harm = Math.floor(this.config.default_harm * (self.ghd + self.gain.ghd));
       fn && fn(this.config);
       return this;
     }
@@ -855,7 +903,7 @@ var Damage = class {
     const { goal } = this.config.agent;
     if (this.config.isRealHarm) return this;
     if (this.config.isEvasion) return this;
-    const dpVal = goal.def;
+    const dpVal = goal.def + goal.gain.def;
     fn && fn(this.config);
     if (this.config.harm - dpVal > 0) {
       this.config.harm -= dpVal;
@@ -891,6 +939,142 @@ function giveDamage(self, goal, damage) {
   }
 }
 __name(giveDamage, "giveDamage");
+function giveCure(goal, val) {
+  const upVal = goal.hp + val;
+  if (upVal < goal.maxHp + goal.gain.maxHp) {
+    goal.hp = upVal;
+    return val;
+  } else {
+    const abHp = goal.maxHp + goal.gain.maxHp - goal.hp;
+    goal.hp += abHp;
+    return abHp;
+  }
+}
+__name(giveCure, "giveCure");
+function moreDamageInfo(damage) {
+  return (damage.isCsp ? `（暴击！）` : "") + (damage.isEvasion ? `（闪避成功！）` : "") + (damage.isBadDef ? `（未破防！）` : "");
+}
+__name(moreDamageInfo, "moreDamageInfo");
+
+// src/skillFn.ts
+var skillFn = {
+  "重砍": {
+    name: "重砍",
+    type: "伤害技" /* 伤害技 */,
+    info: "[伤害技]消耗10MP，对敌方一个单位造成基于攻击力1.2倍伤害。该次伤害无视敌方30%防御！（最低无视1防御）",
+    lv: 3,
+    mp: 10,
+    feature: ["剑士" /* 剑士 */],
+    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.2);
+          val.agent.goal.def -= Math.floor(val.agent.goal.def * 0.3) || 1;
+        }, "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: "[伤害技]消耗10MP，对敌方一个单位造成基于攻击力1.2倍伤害，该伤害无视敌方闪避10%",
+    lv: 3,
+    mp: 10,
+    feature: ["刺客" /* 刺客 */],
+    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.2);
+          val.agent.goal.evasion -= Math.floor((val.agent.goal.evasion + val.agent.goal.gain.evasion) * 0.1);
+        }, "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: "[伤害技]消耗10MP，通过凝集魔力对敌方造成基于攻击力1.2倍伤害，该伤害基于当前剩余魔法值10%额外叠加伤害。",
+    lv: 3,
+    mp: 10,
+    feature: ["法师" /* 法师 */],
+    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.2) + Math.floor(val.agent.self.mp * 0.1);
+        }, "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: "[伤害技]血量低于40%可释放，消耗20MP，对敌方一个单位造成基于攻击力2倍伤害。该次伤害暴击率提高20%",
+    lv: 3,
+    mp: 20,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      if (agent.self.hp / (agent.self.maxHp + agent.self.gain.maxHp) < 0.4) {
+        const damageData = new Damage(agent).result({
+          before: /* @__PURE__ */ __name((val) => {
+            val.default_harm += val.default_harm;
+            val.agent.self.chr += 200;
+          }, "before")
+        });
+        fn({
+          damage: damageData,
+          type: this.type,
+          target: [agent.goal],
+          isNext: false
+        });
+        return `${getLineupName(agent.self)} 释放濒死一击，对 ${getLineupName(agent.goal)} 造成 ${damageData.harm} 伤害。` + moreDamageInfo(damageData);
+      } else {
+        fn({
+          type: "释放失败" /* 释放失败 */,
+          isNext: true,
+          err: "释放失败，未达成条件。"
+        });
+        return ``;
+      }
+    }, "fn")
+  },
+  "初级治愈": {
+    name: "初级治愈",
+    type: "治疗技" /* 治疗技 */,
+    info: "[治疗技]直接恢复自身或者目标 40HP",
+    lv: 1,
+    mp: 30,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      const selectGoal = agent.goal;
+      fn({
+        value: 40,
+        target: [selectGoal],
+        type: "治疗技" /* 治疗技 */,
+        isNext: false
+      });
+      return `${getLineupName(agent.self)}释放初级治愈，${getLineupName(agent.goal)}恢复40HP`;
+    }, "fn")
+  }
+};
 
 // src/battle.ts
 var BattleData = {
@@ -921,8 +1105,12 @@ var BattleData = {
   // 返回队伍信息
   teamListByUser(userId) {
     const teamList = [];
+    if (!BattleData.teamTemp[userId]) {
+      return [];
+    }
+    const _userId = BattleData.teamTemp[userId].for;
     Object.keys(BattleData.teamTemp).forEach((item) => {
-      if (BattleData.teamTemp[item].for == userId) {
+      if (BattleData.teamTemp[item].for == _userId) {
         teamList.push(User.getUserAttributeByUserId(item));
       }
     });
@@ -1024,7 +1212,8 @@ var BattleData = {
     team.self.forEach((item) => {
       if (item.hp > 0) {
         selfTemp.push(`lv.${item.lv}[${item.name}]:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})`);
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
         selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
       }
@@ -1032,7 +1221,8 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     team.goal.forEach((item) => {
       if (item.hp > 0) {
         goalTemp.push(`lv.${item.lv}[${item.name}]:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})`);
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
         goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
       }
@@ -1051,13 +1241,13 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     const self = team.self.every((item) => item.hp <= 0);
     const goal = team.goal.every((item) => item.hp <= 0);
     if (self && goal) {
-      return { over: true, type: "平局" };
+      return { over: true, type: "平局", win: "" };
     } else if (self) {
-      return { over: true, type: team.isPK ? "敌方赢" : "防御方赢" };
+      return { over: true, type: team.isPK ? "防御方赢" : "敌方赢", win: "goal" };
     } else if (goal) {
-      return { over: true, type: team.isPK ? "我方赢" : "攻击方赢" };
+      return { over: true, type: team.isPK ? "攻击方赢" : "我方赢", win: "self" };
     }
-    return { over: false, type: "未结束" };
+    return { over: false, type: "未结束", win: "" };
   },
   /** 清理战场 */
   clearBattleData(session) {
@@ -1084,27 +1274,79 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     for (const agent of allAgentList) {
       if (agent.hp <= 0) 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 damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
-      giveDamage(agent, selectGoal, damageInfo);
-      msgList.push(
-        `[${agent.type}]${agent.name} 使用普攻攻击了 [${selectGoal.type}]${selectGoal.name}，造成了${damageInfo.harm}伤害。` + (damageInfo.isCsp ? `（暴击！）` : "") + (damageInfo.isEvasion ? `（闪避成功！）` : "") + (damageInfo.isBadDef ? `（未破防！）` : "")
-      );
+      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;
+          }
+          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;
+                }
+                isNext = val.isNext;
+              }
+            );
+            fnMsg && msgList.push(fnMsg);
+            isNext && noralAtk();
+          } else {
+            await session.send(`MP不足，释放失败！`);
+            noralAtk();
+          }
+        } else {
+          await session.send(`未持有该技能或者该技能不存在，释放失败！`);
+          noralAtk();
+        }
+      }
     }
     await session.send(msgList.length ? `战斗记录：
 ` + msgList.join("\n") : "");
@@ -1112,10 +1354,61 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     const result = BattleData.playOver(currentBattle);
     if (result.over) {
       await session.send(result.type);
+      await BattleData.settlement(currentBattle, result, session);
       BattleData.clearBattleData(session);
     }
+  },
+  /** 结算奖励 */
+  async settlement(tempData, overInfo, session) {
+    const selfList = tempData.self.filter((item) => item.type == "玩家");
+    const goalList = tempData.goal.filter((item) => item.type == "玩家");
+    const msg = /* @__PURE__ */ __name(async (val) => {
+      const msgTemp = `${val.name}[升级]${val.lv}级！
+` + (val.atk ? `攻击力↑ ${val.atk}
+` : "") + (val.def ? `防御力↑ ${val.def}
+` : "") + (val.maxHp ? `最大血量↑ ${val.maxHp}
+` : "") + (val.maxMp ? `最大蓝量↑ ${val.maxMp}` : "");
+      await session.send(msgTemp);
+    }, "msg");
+    const aynchronize = /* @__PURE__ */ __name((agent) => {
+      User.userTempData[agent.userId].hp = agent.hp;
+      User.userTempData[agent.userId].mp = agent.mp;
+    }, "aynchronize");
+    if (tempData.isPK) {
+      if (overInfo.win == "self") {
+        await session.send("攻击方获得20EXP");
+        for (const agent of selfList) {
+          aynchronize(agent);
+          await User.giveExp(agent.userId, 20, async (val) => await msg(val));
+        }
+      } else if (overInfo.win == "goal") {
+        await session.send("防御方获得20EXP");
+        for (const agent of goalList) {
+          aynchronize(agent);
+          await User.giveExp(agent.userId, 20, async (val) => await msg(val));
+        }
+      }
+    } else {
+      let val = 0;
+      const monsterName = tempData.goal.filter((item) => item.type == "怪物").map((i) => ({ name: i.name, lv: i.lv }));
+      monsterName.forEach((item) => {
+        const monster = Monster.monsterTempData[item.name];
+        if (monster[item.name]) {
+          val += monster[item.name].giveExp + monster[item.name].giveExp * (monster[item.name].lv - 1) * 0.2;
+        }
+      });
+      for (const agent of selfList) {
+        aynchronize(agent);
+        await session.send(`小队获得${val}EXP`);
+        await User.giveExp(agent.userId, val, async (val2) => await msg(val2));
+      }
+    }
   }
 };
+function getLineupName(agent) {
+  return `[${agent.type}]${agent.name}`;
+}
+__name(getLineupName, "getLineupName");
 function initBattleAttribute(data) {
   if ("playName" in data) {
     const userData = data;
@@ -1147,27 +1440,28 @@ function initBattleAttribute(data) {
         hit: 0,
         speed: 0
       },
-      buff: []
+      buff: [],
+      fn: []
     };
     return temp;
   } else {
-    const monsterData = data;
+    const monsterData2 = data;
     const temp = {
-      name: monsterData.name,
+      name: monsterData2.name,
       type: "怪物",
-      lv: monsterData.lv,
-      hp: monsterData.hp,
-      maxHp: monsterData.maxHp,
-      mp: monsterData.mp,
-      maxMp: monsterData.maxMp,
-      atk: monsterData.atk,
-      def: monsterData.def,
-      chr: monsterData.chr,
-      ghd: monsterData.ghd,
+      lv: monsterData2.lv,
+      hp: monsterData2.hp,
+      maxHp: monsterData2.maxHp,
+      mp: monsterData2.mp,
+      maxMp: monsterData2.maxMp,
+      atk: monsterData2.atk,
+      def: monsterData2.def,
+      chr: monsterData2.chr,
+      ghd: monsterData2.ghd,
       csr: 0,
-      evasion: monsterData.evasion,
-      hit: monsterData.hit,
-      speed: monsterData.speed,
+      evasion: monsterData2.evasion,
+      hit: monsterData2.hit,
+      speed: monsterData2.speed,
       gain: {
         maxHp: 0,
         maxMp: 0,
@@ -1179,7 +1473,8 @@ function initBattleAttribute(data) {
         hit: 0,
         speed: 0
       },
-      buff: []
+      buff: [],
+      fn: []
     };
     return temp;
   }
@@ -1313,7 +1608,7 @@ function apply(ctx, config) {
     GensokyoMap.initUserPoistion(session, userData);
     const areaInfo = GensokyoMap.getUserCurrentArea(session.userId);
     if (goal) {
-      if (!areaInfo.monster.map((i) => i.name).includes(goal)) {
+      if (!areaInfo.monster?.map((i) => i.name).includes(goal)) {
         return `没有在该区域找到该怪物。`;
       }
       const selectMonster = areaInfo.monster.find((i) => i.name == goal);
@@ -1328,6 +1623,11 @@ function apply(ctx, config) {
     if (!userData) return;
     BattleData.play(session, "普攻", goal);
   });
+  ctx.command("幻想乡/打怪技能 <skill> <goal>").action(async ({ session }, skill, goal) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    BattleData.play(session, skill, goal);
+  });
   ctx.command("打怪pk <goal>").action(async ({ session }, goal) => {
     const userData = await User.getUserAttribute(session);
     if (!userData) return;
@@ -1351,6 +1651,12 @@ function apply(ctx, config) {
       await BattleData.createBattleByUser(session, [{ userId: exist.userId }]);
     }
   });
+  ctx.command("技能查询 <goal>").action(async ({ session }, goal) => {
+    if (!goal) return `请输入技能名，例如 /技能查询 重砍`;
+    if (!skillFn[goal]) return `没有存在 ${goal} 技能！`;
+    return `[${goal}]信息如下：
+` + skillFn[goal].info;
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/monster.d.ts

@@ -1,14 +1,11 @@
 import { Context } from "koishi";
 import { Config } from ".";
+import { MonsterOccupation } from "./data/initMonster";
 declare module 'koishi' {
     interface Tables {
         smm_gensokyo_monster_attribute: MonsterBaseAttribute;
     }
 }
-export declare enum MonsterOccupation {
-    野怪 = "\u91CE\u602A",
-    BOSS = "BOSS"
-}
 /** 怪物基础属性 */
 export type MonsterBaseAttribute = {
     /** 凭据ID */
@@ -41,6 +38,8 @@ export type MonsterBaseAttribute = {
     hit: number;
     /** 出手速度 */
     speed: number;
+    /** 获得经验 */
+    giveExp: number;
 };
 type MonsterTempData = {
     [keys: string]: MonsterBaseAttribute;

package/lib/skillFn.d.ts

@@ -0,0 +1,82 @@
+import { BattleAttribute } from "./battle";
+import { DamageConfig } from "./damage";
+import { UserOccupation } from "./users";
+export declare enum SkillType {
+    释放失败 = "\u91CA\u653E\u5931\u8D25",
+    伤害技 = "\u4F24\u5BB3\u6280",
+    增益技 = "\u589E\u76CA\u6280",
+    治疗技 = "\u6CBB\u7597\u6280",
+    奥义 = "\u5965\u4E49"
+}
+interface DamageSkillParams {
+    /** 伤害类型 */
+    type: SkillType.伤害技;
+    /** 伤害信息 */
+    damage: DamageConfig;
+    /** 释放目标 */
+    target: BattleAttribute[];
+    /** 是否衔接普攻 */
+    isNext: boolean;
+}
+interface HealSkillParams {
+    type: SkillType.治疗技;
+    /** 是否衔接普攻 */
+    isNext: boolean;
+    /** 治疗量 */
+    value: number;
+    target: BattleAttribute[];
+}
+interface BuffSkillParams {
+    type: SkillType.增益技;
+    buffs: {
+        val: number;
+        time: number;
+        name: number;
+    }[];
+    target: BattleAttribute | BattleAttribute[];
+    /** 是否衔接普攻 */
+    isNext: boolean;
+}
+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/test.d.ts

@@ -0,0 +1,13 @@
+declare const nameList: {
+    readonly 张三: {
+        readonly age: 25;
+    };
+    readonly 李四: {
+        readonly age: 30;
+    };
+};
+declare const fn: (name: keyof typeof nameList) => {
+    readonly age: 25;
+} | {
+    readonly age: 30;
+};

package/lib/users.d.ts

@@ -115,5 +115,16 @@ export declare const User: {
     createPlayUser(session: Session): Promise<void>;
     /** 信息格式化 */
     userAttributeTextFormat(userId: string): string;
+    /** 写入用户数据到数据库 */
+    setDatabaseUserAttribute(userId: string): Promise<void>;
+    /** 给予玩家经验 */
+    giveExp(userId: string, value: number, fn?: (upData: {
+        maxHp: number;
+        maxMp: number;
+        atk: number;
+        def: number;
+        lv: number;
+        name: string;
+    }) => Promise<void>): Promise<void>;
 };
 export {};

package/package.json

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