koishi-plugin-smmcat-gensokyo 0.0.14 → 0.0.15

package/lib/index.js

@@ -191,6 +191,7 @@ var GensokyoMap = {
           floor: 1,
           areaName: "绿野平原三",
           type: "冒险区" /* 冒险区 */,
+          monster: [{ name: "dora", lv: 5 }],
           needLv: 1,
           left: "绿野平原一",
           down: "绿野平原六"
@@ -442,6 +443,58 @@ var userBenchmark = {
   }
 };
 
+// src/data/initProps.ts
+var propsData = {
+  "红药": {
+    name: "红药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20HP",
+    price: 10,
+    fn: /* @__PURE__ */ __name(function(session) {
+      User.giveHPMP(session.userId, { hp: 20 }, async (val) => {
+        if (val.err) {
+          await session.send(val.err);
+          return;
+        }
+        const msg = `回复成功，玩家当前血量：${val.currentHP}`;
+        await session.send(msg);
+      });
+    }, "fn")
+  },
+  "蓝药": {
+    name: "蓝药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20MP",
+    price: 10,
+    fn: /* @__PURE__ */ __name(function(session) {
+      User.giveHPMP(session.userId, { mp: 20 }, async (val) => {
+        if (val.err) {
+          await session.send(val.err);
+          return;
+        }
+        const msg = `回复成功，玩家当前蓝量：${val.currentMP}`;
+        await session.send(msg);
+      });
+    }, "fn")
+  },
+  "初级万能药": {
+    name: "初级万能药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20MP和20HP",
+    price: 20,
+    fn: /* @__PURE__ */ __name(function(session) {
+      User.giveHPMP(session.userId, { hp: 20, mp: 20 }, async (val) => {
+        if (val.err) {
+          await session.send(val.err);
+          return;
+        }
+        const msg = `回复成功，玩家当前血量：${val.currentHP}、蓝量：${val.currentMP}`;
+        await session.send(msg);
+      });
+    }, "fn")
+  }
+};
+
 // src/props.ts
 var Props = {
   config: {},
@@ -475,1196 +528,1378 @@ var Props = {
       await Props.ctx.database.create("smm_gensokyo_user_props", temp);
     }
   },
+  /** 获取持有道具信息 */
+  async getPropsDataByUserId(userId) {
+    await Props.initUserPropsData(userId);
+    const userProps = Props.userPorpsTemp[userId];
+    const msgList = Object.keys(userProps).map((item) => {
+      return `${userProps[item].name}:${userProps[item].value}个`;
+    });
+    return msgList.length ? `当前您持有如下道具：
+
+` + msgList.join("\n") : "您没有任何道具...";
+  },
   /** 更新本地数据库对应数据 */
   async setDatabasePropsData(userId) {
-    const propsData = Props.userPorpsTemp[userId];
-    if (propsData) {
+    const propsData2 = Props.userPorpsTemp[userId];
+    if (propsData2) {
       const temp = {
-        props: propsData
+        props: propsData2
       };
       await Props.ctx.database.set("smm_gensokyo_user_props", { userId }, temp);
     }
+  },
+  async userProps(session, propsName) {
+    const userPropsData = Props.userPorpsTemp[session.userId];
+    if (!userPropsData) return;
+    if (!userPropsData[propsName]) {
+      await session.send(`您似乎没有${propsName}这个道具...`);
+      return;
+    }
+    User.loseProps(session.userId, { name: propsName, val: 1 }, async (val) => {
+      if (val.err) {
+        await session.send(val.err);
+        return;
+      }
+      propsData[propsName].fn(session);
+    });
   }
 };
 
-// src/users.ts
-var UserOccDict = {
-  ["剑士" /* 剑士 */]: {
-    info: "擅长近战攻击，拥有强大的属性能力",
-    initStatus: {
-      userId: "",
-      playName: "",
-      type: "剑士" /* 剑士 */,
-      exp: 0,
-      maxExp: 100,
-      lv: 1,
-      hp: 120,
-      maxHp: 120,
-      mp: 80,
-      maxMp: 80,
-      pp: 100,
-      maxPp: 100,
-      atk: 12,
-      def: 5,
-      chr: 50,
-      csr: 0,
-      ghd: 1.2,
-      speed: 5,
-      evasion: 100,
-      hit: 100
-    }
+// src/monster.ts
+var import_koishi = require("koishi");
+
+// src/data/initMonster.ts
+var monsterData = {
+  "小蜜蜂": {
+    name: "小蜜蜂",
+    type: "野怪" /* 野怪 */,
+    info: "幻想乡一层常见的生物",
+    pic: "http://smmcat.cn/run/gensokyo/小蜜蜂.png",
+    hp: 50,
+    maxHp: 50,
+    mp: 30,
+    maxMp: 30,
+    atk: 7,
+    def: 2,
+    chr: 50,
+    csr: 0,
+    evasion: 100,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 10,
+    giveMonetary: 2,
+    giveProps: [
+      { name: "红药", val: 3, radomVal: 30 }
+    ]
   },
-  ["法师" /* 法师 */]: {
-    info: "精通元素魔法，能够打出爆发伤害",
-    initStatus: {
-      userId: "",
-      playName: "",
-      type: "法师" /* 法师 */,
-      exp: 0,
-      maxExp: 100,
-      lv: 1,
-      hp: 100,
-      maxHp: 100,
-      mp: 100,
-      maxMp: 100,
-      pp: 100,
-      maxPp: 100,
-      atk: 10,
-      def: 2,
-      chr: 50,
-      csr: 0,
-      ghd: 1.2,
-      speed: 5,
-      evasion: 100,
-      hit: 100
-    }
+  "小蜘蛛": {
+    name: "小蜘蛛",
+    type: "野怪" /* 野怪 */,
+    info: "幻想乡一层常见的生物",
+    pic: "http://smmcat.cn/run/gensokyo/小蜘蛛.png",
+    hp: 55,
+    maxHp: 55,
+    mp: 30,
+    maxMp: 30,
+    atk: 10,
+    def: 3,
+    chr: 50,
+    csr: 0,
+    evasion: 150,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 12,
+    giveMonetary: 2,
+    giveProps: [
+      { name: "蓝药", val: 3, radomVal: 30 }
+    ]
   },
-  ["刺客" /* 刺客 */]: {
-    info: "迅捷攻击，高闪避值的高敏玩家",
-    initStatus: {
-      userId: "",
-      playName: "",
-      type: "刺客" /* 刺客 */,
-      exp: 0,
-      maxExp: 100,
-      lv: 1,
-      hp: 90,
-      maxHp: 90,
-      mp: 70,
-      maxMp: 70,
-      pp: 100,
-      maxPp: 100,
-      atk: 8,
-      def: 2,
-      chr: 80,
-      csr: 0,
-      ghd: 1.3,
-      speed: 6,
-      evasion: 120,
-      hit: 100
-    }
+  "dora": {
+    name: "dora",
+    type: "野怪" /* 野怪 */,
+    info: "偶尔出没在一层世界的奇怪生物",
+    pic: "http://smmcat.cn/run/gensokyo/dora.png",
+    hp: 88,
+    maxHp: 88,
+    mp: 10,
+    maxMp: 10,
+    atk: 20,
+    def: 5,
+    chr: 200,
+    csr: 0,
+    evasion: 200,
+    hit: 1e3,
+    ghd: 1.2,
+    speed: 4,
+    giveExp: 15,
+    giveMonetary: 3,
+    giveProps: [
+      { name: "蓝药", val: 3, radomVal: 30 },
+      { name: "初级万能药", val: 2, radomVal: 90, const: true, lv: 5 }
+    ]
   }
 };
-var User = {
+
+// src/monster.ts
+var Monster = {
   config: {},
   ctx: {},
-  userTempData: {},
+  monsterTempData: {},
   async init(config, ctx) {
-    User.config = config;
-    User.ctx = ctx;
+    Monster.config = config;
+    Monster.ctx = ctx;
     ctx.model.extend(
-      "smm_gensokyo_user_attribute",
+      "smm_gensokyo_monster_attribute",
       {
-        userId: "string",
-        playName: "string",
+        id: "integer",
+        name: "string",
+        info: "string",
         type: "string",
-        exp: "integer",
-        lv: "integer",
         hp: "integer",
+        maxHp: "integer",
         mp: "integer",
-        pp: "integer",
-        isDie: "boolean"
+        maxMp: "integer",
+        atk: "integer",
+        def: "integer",
+        chr: "integer",
+        evasion: "integer",
+        hit: "integer",
+        ghd: "integer",
+        speed: "integer"
       },
       {
-        primary: "userId",
+        primary: "id",
         autoInc: false
       }
     );
-    const userData = await ctx.database.get("smm_gensokyo_user_attribute", {});
-    const temp = {};
-    userData.forEach((item) => {
-      temp[item.userId] = item;
-    });
-    User.userTempData = temp;
-  },
-  /** 获取角色基础属性 */
-  async getUserAttribute(session) {
-    if (!User.userTempData[session.userId]) {
-      await session.send("未创建账户，请发送 /开始注册 完成账号的注册！");
-      return null;
+    const monsterData2 = await ctx.database.get("smm_gensokyo_monster_attribute", {});
+    if (monsterData2.length == 0) {
+      Monster.monsterTempData = Monster._createInitMonsterData();
+    } else {
+      const temp = {};
+      monsterData2.forEach((item) => {
+        temp[item.id] = item;
+      });
+      Monster.monsterTempData = temp;
     }
-    return User.getUserAddLvAttribute(session.userId);
   },
-  /** 获取角色实际等级属性数据 */
-  getUserAddLvAttribute(userId) {
-    const UserDict = User.userTempData[userId];
-    if (!UserDict) return null;
-    const UserData = {
-      ...UserOccDict[UserDict.type].initStatus,
-      lv: UserDict.lv,
-      hp: UserDict.hp,
-      mp: UserDict.mp,
-      exp: UserDict.exp,
-      pp: UserDict.pp,
-      playName: UserDict.playName,
-      userId: UserDict.userId
-    };
-    const lv = UserData.lv;
-    const temp = {};
-    const lvScope = Object.keys(userBenchmark).reverse().find((item) => Number(item) < lv) || 10;
-    const useBenchmark = userBenchmark[lvScope];
-    Object.keys(UserData).forEach((i) => {
-      temp[i] = UserData[i];
+  /** 赋予原始的怪物数据 */
+  _createInitMonsterData() {
+    return monsterData;
+  },
+  getMonsterAttributeData(monsterName, lv) {
+    const monster = Monster.monsterTempData[monsterName];
+    if (!monster) return null;
+    const temp = { lv };
+    const lvScope = Object.keys(monsterBenchmark).reverse().find((item) => Number(item) < lv) || 10;
+    const useBenchmark = monsterBenchmark[lvScope];
+    console.log(useBenchmark);
+    Object.keys(monster).forEach((i) => {
+      temp[i] = monster[i];
       if (useBenchmark[i]) {
-        if (i == "maxExp") {
-          temp[i] = Math.floor(100 * useBenchmark[i] * (lv - 1)) || 100;
-        } else {
-          temp[i] += Math.floor(temp[i] * (useBenchmark[i] - 1) * (lv - 1));
-        }
+        temp[i] += Math.floor(temp[i] * (useBenchmark[i] - 1) * (lv - 1));
       }
     });
     return temp;
   },
-  /** 通过 userId 获取角色属性 */
-  getUserAttributeByUserId(userId) {
-    return User.getUserAddLvAttribute(userId) || null;
-  },
-  /** 创建游戏账号 */
-  async createPlayUser(session) {
-    const [data] = await User.ctx.database.get("smm_gensokyo_user_attribute", { userId: session.userId });
-    if (data) {
-      await session.send("已存在账号，请勿重复创建！");
-      return;
+  /** 格式化怪物属性数据 */
+  monsterAttributeTextFormat(monster) {
+    const { name: name2, type, lv, hp, maxHp, mp, maxMp, atk, def, chr, evasion, hit, ghd, speed, info, pic, giveProps } = monster;
+    const propsList = giveProps.filter((item) => item.lv ? lv >= item.lv : true).map((item) => item.name);
+    const attributeText = (pic ? import_koishi.h.image(pic) + "\n" : "") + `Lv.${lv}【${name2}】
+
+【怪物类型】${type}
+【生命值】${hp}/${maxHp}
+【魔法值】${mp}/${maxMp}
+【攻击力】${atk}
+【防御力】${def}
+【闪避值】${evasion}
+【命中值】${hit}
+【速度值】${speed}
+【暴击率】${(chr / 10).toFixed(1)}%
+【爆伤倍率】${(ghd * 100).toFixed(0)}%` + (propsList?.length ? `
+【概率掉落道具】` + propsList.join("、") : "") + (info ? "\n\n" + info : "");
+    return attributeText;
+  }
+};
+
+// src/utlis.ts
+var random = /* @__PURE__ */ __name((min, max) => {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}, "random");
+var generateHealthDisplay = /* @__PURE__ */ __name((current, total) => {
+  const ratio = current / total;
+  const displayLength = 10;
+  const filledLength = Math.floor(ratio * displayLength);
+  const unfilledLength = displayLength - filledLength;
+  const filled = "■".repeat(filledLength);
+  const unfilled = "□".repeat(unfilledLength);
+  return filled + unfilled;
+}, "generateHealthDisplay");
+
+// src/damage.ts
+var Damage = class {
+  static {
+    __name(this, "Damage");
+  }
+  config;
+  constructor(agent, realHarm = false) {
+    this.config = {
+      agent: { self: { ...agent.self }, goal: { ...agent.goal } },
+      harm: 0,
+      default_harm: 0,
+      isRealHarm: realHarm,
+      isEvasion: false,
+      isCsp: false,
+      isBadDef: false
+    };
+  }
+  /** 伤害判定前 */
+  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.isRealHarm) {
+      this.config.harm = this.config.default_harm;
     }
-    await session.send("请输入自己的游戏昵称：(60s)");
-    const playname = await session.prompt(6e4);
-    if (playname == void 0) return;
-    const [repeat] = await User.ctx.database.get("smm_gensokyo_user_attribute", { playName: playname.trim() });
-    if (repeat) {
-      await session.send("名字重复，请更换一个名字。");
-      return;
+    return this;
+  }
+  /** 是否闪避判定 */
+  evasion(fn) {
+    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 + goal.gain.evasion - self.hit + lvSup()) / 10);
+    if (random(0, 100) <= evaVal) {
+      this.config.isEvasion = true;
+      fn && fn(this.config);
+      return this;
     }
-    if (playname.trim().length > 6 || playname.trim().length < 1) {
-      await session.send("名字长度有问题，要求小于 6个字，大于 1个字");
-      return;
+    fn && fn(this.config);
+    return this;
+  }
+  /** 是否暴击判定 */
+  csp(fn) {
+    const { self, goal } = this.config.agent;
+    if (this.config.isRealHarm) return this;
+    if (this.config.isEvasion) return this;
+    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 + self.gain.ghd));
+      fn && fn(this.config);
+      return this;
     }
-    await session.send(`请输入要专职的职业：（60s）
-${Object.keys(UserOccDict).map((i) => `【${i}】:${UserOccDict[i].info}`).join("\n")}`);
-    let jobType = await session.prompt(6e4);
-    if (jobType == void 0) return;
-    while (!Object.keys(UserOccDict).includes(jobType)) {
-      await session.send("未找到该职业，请重新选择！");
-      jobType = await session.prompt(6e4);
+    this.config.harm = this.config.default_harm;
+    fn && fn(this.config);
+    return this;
+  }
+  /** 防御结算 */
+  beforDef(fn) {
+    const { goal } = this.config.agent;
+    if (this.config.isRealHarm) return this;
+    if (this.config.isEvasion) return this;
+    const dpVal = goal.def + goal.gain.def;
+    fn && fn(this.config);
+    if (this.config.harm - dpVal > 0) {
+      this.config.harm -= dpVal;
+    } else {
+      this.config.isBadDef = true;
+      this.config.harm = 1;
     }
-    const temp = {
-      userId: session.userId,
-      playName: playname.trim(),
-      type: jobType,
-      hp: UserOccDict[jobType].initStatus.hp,
-      pp: UserOccDict[jobType].initStatus.pp,
-      mp: UserOccDict[jobType].initStatus.mp,
-      lv: 1,
-      exp: 0,
-      isDie: false
-    };
-    User.ctx.database.create("smm_gensokyo_user_attribute", temp);
-    User.userTempData[session.userId] = temp;
-    await Props.initUserPropsData(session.userId);
-    await session.send("创建成功！\n" + User.userAttributeTextFormat(session.userId));
+    return this;
+  }
+  result(fn) {
+    this.before((val) => {
+      fn?.before && fn.before(val);
+    }).beforRealHarm((val) => {
+      fn?.beforRealHarm && fn.beforRealHarm(val);
+    }).evasion((val) => {
+      fn?.evasion && fn.evasion(val);
+    }).csp((val) => {
+      fn?.csp && fn.csp(val);
+    }).beforDef((val) => {
+      fn?.beforDef && fn.beforDef(val);
+    });
+    return this.config;
+  }
+};
+function giveDamage(self, goal, damage) {
+  if (goal.hp - damage.harm > 0) {
+    goal.hp -= damage.harm;
+    return damage.harm;
+  } else {
+    const lostHp = goal.hp;
+    goal.hp = 0;
+    return lostHp;
+  }
+}
+__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")
   },
-  /** 信息格式化 */
-  userAttributeTextFormat(userId) {
-    if (!User.userTempData[userId]) {
-      return "没有找到您的角色信息";
-    }
-    const temp = User.getUserAttributeByUserId(userId);
-    return `昵称：${temp.playName}
-职位：${temp.type}
-等级：${temp.lv} (${temp.exp}/${temp.maxExp})
------------------
-【生命值】${temp.hp}/${temp.maxHp}
-【魔法值】${temp.mp}/${temp.maxMp}
-【活力值】${temp.pp}/${temp.maxPp}
------------------
-【攻击力】${temp.atk} (+0)
-【防御力】${temp.def} (+0)
-【速度值】${temp.speed} (+0)
-【闪避值】${temp.evasion} (+0)
-【命中率】${(temp.hit / 10 + 100).toFixed(1)}% (+0%)
-【暴击率】${(temp.chr / 10).toFixed(1)}% (+0%)
-【暴击伤害】${(temp.ghd * 100).toFixed(1)}% (+0%)` + (temp.csr > 0 ? `
-【暴击抵抗】${temp.csr}` : "");
+  "突刺": {
+    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")
   },
-  /** 写入用户数据到数据库 */
-  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);
+  "水炮": {
+    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")
   },
-  /** 给予玩家经验 */
-  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);
+  "濒死一击": {
+    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")
   },
-  /** 给予玩家死亡 */
-  async giveDie(userId) {
-    const userInfo = User.userTempData[userId];
-    userInfo.hp = 0;
-    userInfo.isDie = true;
-    await User.setDatabaseUserAttribute(userId);
+  "初级治愈": {
+    name: "初级治愈",
+    type: "治疗技" /* 治疗技 */,
+    info: "[治疗技]直接恢复自身或者目标 40HP",
+    lv: 1,
+    mp: 30,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      const selectGoal = agent.goal;
+      if (agent.goal.hp <= 0) {
+        return `${getLineupName(agent.self)}已阵亡，无法恢复...`;
+      }
+      fn({
+        value: 40,
+        target: [selectGoal],
+        type: "治疗技" /* 治疗技 */,
+        isNext: false
+      });
+      return `${getLineupName(agent.self)}释放初级治愈，${getLineupName(agent.goal)}恢复40HP`;
+    }, "fn")
+  }
+};
+
+// src/battle.ts
+var BattleData = {
+  config: {},
+  ctx: {},
+  historyTemp: {},
+  lastPlay: {},
+  teamTemp: {},
+  init(config, ctx) {
+    this.config = config;
+    this.ctx = ctx;
   },
-  /** 给予玩家恢复 */
-  async giveLife(userId, val) {
-    const userInfo = User.userTempData[userId];
-    if (!val) {
-      const { maxHp } = User.getUserAttributeByUserId(userId);
-      userInfo.hp = maxHp;
-    } else {
-      userInfo.hp = val;
-    }
-    await User.setDatabaseUserAttribute(userId);
+  /** 玩家是否正在战斗 */
+  isBattle(session) {
+    return !!BattleData.lastPlay[session.userId];
   },
-  /** 给予玩家血量或者蓝量 */
-  async giveHPMP(userId, value, fn) {
-    const userInfo = User.userTempData[userId];
-    if (!userInfo) return;
-    if (userInfo.isDie) {
-      fn && await fn({
-        currentHP: 0,
-        currentMP: 0,
-        err: "角色已死亡，无法使用恢复道具。"
-      });
-      return;
-    }
-    const { maxHp, maxMp } = User.getUserAttributeByUserId(userId);
-    if (userInfo.hp + (value.hp || 0) < maxHp) {
-      userInfo.hp += value.hp || 0;
-    } else {
-      userInfo.hp = maxHp;
-    }
-    if (userInfo.mp + (value.mp || 0) < maxHp) {
-      userInfo.mp += value.mp || 0;
-    } else {
-      userInfo.mp = maxMp;
+  /** 玩家是否正在战斗 */
+  isBattleByUserId(userId) {
+    return !!BattleData.lastPlay[userId];
+  },
+  /** 玩家是否在队伍中 */
+  isTeam(session) {
+    return !!BattleData.teamTemp[session.userId];
+  },
+  isTeamByUserId(userId) {
+    return !!BattleData.teamTemp[userId];
+  },
+  // 返回队伍信息
+  teamListByUser(userId) {
+    const teamList = [];
+    if (!BattleData.teamTemp[userId]) {
+      return [];
     }
-    fn && await fn({
-      currentHP: userInfo.hp,
-      currentMP: userInfo.mp
+    const _userId = BattleData.teamTemp[userId].for;
+    Object.keys(BattleData.teamTemp).forEach((item) => {
+      if (BattleData.teamTemp[item].for == _userId) {
+        teamList.push(User.getUserAttributeByUserId(item));
+      }
     });
-    await User.setDatabaseUserAttribute(userId);
+    return teamList;
   },
-  /** 给予玩家PP值 */
-  async givePP(userId, value, fn) {
-    const userInfo = User.userTempData[userId];
-    if (!userInfo) return;
-    const { maxPp } = User.getUserAttributeByUserId(userId);
-    if (userInfo.pp + value < maxPp) {
-      userInfo.pp += value;
+  /** 创建战斗-与怪物 */
+  async createBattleByMonster(session, goal) {
+    if (BattleData.isBattle(session)) {
+      await session.send("当前正在战斗，还不能逃脱！");
+      return;
+    }
+    const battle_user = [];
+    const battle_monsterList = [];
+    const playUser = [];
+    if (BattleData.isTeam(session) && BattleData.teamTemp[session.userId].identity == "队员") {
+      await session.send("你不是队伍的队长，无法主动操作战斗！");
+      return;
+    } else if (BattleData.isTeam(session)) {
+      Object.keys(BattleData.teamTemp).forEach((item) => {
+        if (BattleData.teamTemp[item].for == session.userId) {
+          playUser.push(item);
+          battle_user.push(initBattleAttribute(User.getUserAttributeByUserId(item)));
+        }
+      });
     } else {
-      userInfo.pp = maxPp;
+      playUser.push(session.userId);
+      battle_user.push(initBattleAttribute(User.getUserAttributeByUserId(session.userId)));
     }
-    fn && await fn({
-      currentPP: userInfo.pp
+    goal.forEach((item) => {
+      battle_monsterList.push(initBattleAttribute(Monster.getMonsterAttributeData(item.name, item.lv)));
     });
-    await User.setDatabaseUserAttribute(userId);
+    const temp = {
+      self: battle_user.map((i) => ({ ...i, for: "self" })),
+      goal: battle_monsterList.map((i) => ({ ...i, for: "goal" }))
+    };
+    playUser.forEach((userId) => {
+      BattleData.lastPlay[userId] = temp;
+    });
+    await session.send(`开始与 ${goal.map((i) => i.name).join("、")} 进行战斗`);
   },
-  /** 给予玩家货币 */
-  async giveMonetary(userId, val, fn) {
-    const [bindData] = await User.ctx.database.get("binding", { pid: userId });
-    if (bindData && val) {
-      const [currentM] = await User.ctx.database.get("monetary", { uid: bindData.aid });
-      await User.ctx.monetary.gain(bindData.aid, val);
-      fn && fn({ val, currentVal: currentM.value += val });
+  /** 创建战斗-与玩家 */
+  async createBattleByUser(session, goal) {
+    if (BattleData.isBattle(session)) {
+      await session.send("当前正在战斗，还不能逃脱！");
+      return;
     }
-  },
-  /** 收取玩家货币 */
-  async lostMonetary(userId, val, fn) {
-    const [bindData] = await User.ctx.database.get("binding", { pid: userId });
-    if (bindData && val) {
-      const [currentM] = await User.ctx.database.get("monetary", { uid: bindData.aid });
-      if (currentM.value - val < 0) {
-        fn && fn({
-          val: Math.abs(val),
-          currentVal: currentM.value,
-          err: "余额不足！"
-        });
-        return;
+    const battle_self = [];
+    const battle_goal = [];
+    const playUser = [];
+    const lostMsg = [];
+    goal = goal.filter((item) => {
+      const isBattle = BattleData.isBattleByUserId(item.userId);
+      const pyUser = User.userTempData[item.userId];
+      if (isBattle) {
+        lostMsg.push(`${pyUser.playName}正在参与着一场战斗，无法被PK选中。`);
+        return false;
       }
-      await User.ctx.monetary.cost(bindData.aid, val);
-      fn && fn({
-        val: Math.abs(val),
-        currentVal: currentM.value - val
+      return true;
+    });
+    if (lostMsg.length) {
+      await session.send(lostMsg.join("\n"));
+    }
+    if (!goal.length) {
+      lostMsg.push(`PK失败，无任何目标进行PK`);
+      return;
+    }
+    if (BattleData.isTeam(session) && BattleData.teamTemp[session.userId].identity == "队员") {
+      await session.send("你不是队伍的队长，无法主动操作战斗！");
+      return;
+    } else if (BattleData.isTeam(session)) {
+      Object.keys(BattleData.teamTemp).forEach((item) => {
+        if (BattleData.teamTemp[item].for == session.userId) {
+          playUser.push(item);
+          battle_self.push(initBattleAttribute(User.getUserAttributeByUserId(item)));
+        }
       });
+    } else {
+      playUser.push(session.userId);
+      battle_self.push(initBattleAttribute(User.getUserAttributeByUserId(session.userId)));
     }
+    goal.forEach((item) => {
+      playUser.push(item.userId);
+      battle_goal.push(initBattleAttribute(User.getUserAttributeByUserId(item.userId)));
+    });
+    const pkTemp = {
+      self: battle_self.map((i) => ({ ...i, for: "self" })),
+      goal: battle_goal.map((i) => ({ ...i, for: "goal" })),
+      isPK: true
+    };
+    playUser.forEach((userId) => {
+      BattleData.lastPlay[userId] = pkTemp;
+    });
+    await session.send(`开始与玩家 ${battle_goal.map((i) => i.name).join("、")} 进行PK战斗`);
   },
-  /** 目标是否死亡 */
-  isDie(userId) {
-    return User.userTempData[userId]?.isDie;
-  }
-};
-
-// src/monster.ts
-var import_koishi = require("koishi");
-
-// src/data/initMonster.ts
-var monsterData = {
-  "小蜜蜂": {
-    name: "小蜜蜂",
-    type: "野怪" /* 野怪 */,
-    info: "幻想乡一层常见的生物",
-    pic: "http://smmcat.cn/run/gensokyo/小蜜蜂.png",
-    hp: 50,
-    maxHp: 50,
-    mp: 30,
-    maxMp: 30,
-    atk: 7,
-    def: 2,
-    chr: 50,
-    csr: 0,
-    evasion: 100,
-    hit: 1e3,
-    ghd: 1.2,
-    speed: 4,
-    giveExp: 10,
-    giveMonetary: 2
-  },
-  "小蜘蛛": {
-    name: "小蜘蛛",
-    type: "野怪" /* 野怪 */,
-    info: "幻想乡一层常见的生物",
-    pic: "http://smmcat.cn/run/gensokyo/小蜘蛛.png",
-    hp: 55,
-    maxHp: 55,
-    mp: 30,
-    maxMp: 30,
-    atk: 10,
-    def: 3,
-    chr: 50,
-    csr: 0,
-    evasion: 150,
-    hit: 1e3,
-    ghd: 1.2,
-    speed: 4,
-    giveExp: 12,
-    giveMonetary: 2
-  },
-  "dora": {
-    name: "dora",
-    type: "野怪" /* 野怪 */,
-    info: "偶尔出没在一层世界的奇怪生物",
-    pic: "http://smmcat.cn/run/gensokyo/dora.png",
-    hp: 88,
-    maxHp: 88,
-    mp: 10,
-    maxMp: 10,
-    atk: 20,
-    def: 5,
-    chr: 200,
-    csr: 0,
-    evasion: 200,
-    hit: 1e3,
-    ghd: 1.2,
-    speed: 4,
-    giveExp: 15,
-    giveMonetary: 3
-  }
-};
-
-// src/monster.ts
-var Monster = {
-  config: {},
-  ctx: {},
-  monsterTempData: {},
-  async init(config, ctx) {
-    Monster.config = config;
-    Monster.ctx = ctx;
-    ctx.model.extend(
-      "smm_gensokyo_monster_attribute",
-      {
-        id: "integer",
-        name: "string",
-        info: "string",
-        type: "string",
-        hp: "integer",
-        maxHp: "integer",
-        mp: "integer",
-        maxMp: "integer",
-        atk: "integer",
-        def: "integer",
-        chr: "integer",
-        evasion: "integer",
-        hit: "integer",
-        ghd: "integer",
-        speed: "integer"
-      },
-      {
-        primary: "id",
-        autoInc: false
+  /** 文本化当前战况 */
+  battleSituationTextFormat(team) {
+    const selfTemp = [];
+    const goalTemp = [];
+    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})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
+      } else {
+        selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
       }
-    );
-    const monsterData2 = await ctx.database.get("smm_gensokyo_monster_attribute", {});
-    if (monsterData2.length == 0) {
-      Monster.monsterTempData = Monster._createInitMonsterData();
-    } else {
-      const temp = {};
-      monsterData2.forEach((item) => {
-        temp[item.id] = item;
-      });
-      Monster.monsterTempData = temp;
+    });
+    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})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
+      } else {
+        goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
+      }
+    });
+    if (team.isPK) {
+      return `[当前战况]
+攻击方：
+` + selfTemp.join("\n") + "\n\n防御方：\n" + goalTemp.join("\n");
     }
+    return `[当前战况]
+我方阵容：
+` + selfTemp.join("\n") + "\n\n敌方阵容：\n" + goalTemp.join("\n");
   },
-  /** 赋予原始的怪物数据 */
-  _createInitMonsterData() {
-    return monsterData;
+  /** 判断输赢 */
+  playOver(team) {
+    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: "平局", win: "" };
+    } else if (self) {
+      return { over: true, type: team.isPK ? "防御方赢" : "敌方赢", win: "goal" };
+    } else if (goal) {
+      return { over: true, type: team.isPK ? "攻击方赢" : "我方赢", win: "self" };
+    }
+    return { over: false, type: "未结束", win: "" };
   },
-  getMonsterAttributeData(monsterName, lv) {
-    const monster = Monster.monsterTempData[monsterName];
-    if (!monster) return null;
-    const temp = { lv };
-    const lvScope = Object.keys(monsterBenchmark).reverse().find((item) => Number(item) < lv) || 10;
-    const useBenchmark = monsterBenchmark[lvScope];
-    console.log(useBenchmark);
-    Object.keys(monster).forEach((i) => {
-      temp[i] = monster[i];
-      if (useBenchmark[i]) {
-        temp[i] += Math.floor(temp[i] * (useBenchmark[i] - 1) * (lv - 1));
+  /** 清理战场 */
+  clearBattleData(session) {
+    const currentBattle = BattleData.lastPlay[session.userId];
+    const allAgentList = [...currentBattle.goal, ...currentBattle.self];
+    allAgentList.forEach((item) => {
+      if (item.type == "玩家") {
+        delete BattleData.lastPlay[item.userId];
       }
     });
-    return temp;
   },
-  /** 格式化怪物属性数据 */
-  monsterAttributeTextFormat(monster) {
-    const { name: name2, type, lv, hp, maxHp, mp, maxMp, atk, def, chr, evasion, hit, ghd, speed, info, pic } = monster;
-    const attributeText = (pic ? import_koishi.h.image(pic) + "\n" : "") + `Lv.${lv}【${name2}】
-
-【怪物类型】${type}
-【生命值】${hp}/${maxHp}
-【魔法值】${mp}/${maxMp}
-【攻击力】${atk}
-【防御力】${def}
-【闪避值】${evasion}
-【命中值】${hit}
-【速度值】${speed}
-【暴击率】${(chr / 10).toFixed(1)}%
-【爆伤倍率】${(ghd * 100).toFixed(0)}%` + (info ? "\n\n" + info : "");
-    return attributeText;
-  }
-};
-
-// src/utlis.ts
-var random = /* @__PURE__ */ __name((min, max) => {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}, "random");
-var generateHealthDisplay = /* @__PURE__ */ __name((current, total) => {
-  const ratio = current / total;
-  const displayLength = 10;
-  const filledLength = Math.floor(ratio * displayLength);
-  const unfilledLength = displayLength - filledLength;
-  const filled = "■".repeat(filledLength);
-  const unfilled = "□".repeat(unfilledLength);
-  return filled + unfilled;
-}, "generateHealthDisplay");
-
-// src/damage.ts
-var Damage = class {
-  static {
-    __name(this, "Damage");
-  }
-  config;
-  constructor(agent, realHarm = false) {
-    this.config = {
-      agent: { self: { ...agent.self }, goal: { ...agent.goal } },
-      harm: 0,
-      default_harm: 0,
-      isRealHarm: realHarm,
-      isEvasion: false,
-      isCsp: false,
-      isBadDef: false
-    };
-  }
-  /** 伤害判定前 */
-  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.isRealHarm) {
-      this.config.harm = this.config.default_harm;
+  async play(session, atkType, select) {
+    if (!BattleData.isBattle(session)) {
+      await session.send("您并没有任何参与战斗。");
+      return;
     }
-    return this;
-  }
-  /** 是否闪避判定 */
-  evasion(fn) {
-    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 + goal.gain.evasion - self.hit + lvSup()) / 10);
-    if (random(0, 100) <= evaVal) {
-      this.config.isEvasion = true;
-      fn && fn(this.config);
-      return this;
+    const currentBattle = BattleData.lastPlay[session.userId];
+    const allAgentList = [...currentBattle.goal, ...currentBattle.self].sort((a, b) => b.speed - a.speed);
+    const msgList = [];
+    for (const agent of allAgentList) {
+      if (agent.hp <= 0) {
+        if (agent.type == "玩家" && !User.userTempData[agent.userId]?.isDie) {
+          User.userTempData[agent.userId].hp = 0;
+          User.userTempData[agent.userId].isDie = true;
+        }
+        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;
+          }
+          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();
+        }
+      }
     }
-    fn && fn(this.config);
-    return this;
-  }
-  /** 是否暴击判定 */
-  csp(fn) {
-    const { self, goal } = this.config.agent;
-    if (this.config.isRealHarm) return this;
-    if (this.config.isEvasion) return this;
-    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 + self.gain.ghd));
-      fn && fn(this.config);
-      return this;
+    await session.send(msgList.length ? `战斗记录：
+` + msgList.join("\n") : "");
+    await session.send(BattleData.battleSituationTextFormat(currentBattle));
+    const result = BattleData.playOver(currentBattle);
+    if (result.over) {
+      await session.send(result.type);
+      await BattleData.settlement(currentBattle, result, session);
+      BattleData.clearBattleData(session);
     }
-    this.config.harm = this.config.default_harm;
-    fn && fn(this.config);
-    return this;
-  }
-  /** 防御结算 */
-  beforDef(fn) {
-    const { goal } = this.config.agent;
-    if (this.config.isRealHarm) return this;
-    if (this.config.isEvasion) return this;
-    const dpVal = goal.def + goal.gain.def;
-    fn && fn(this.config);
-    if (this.config.harm - dpVal > 0) {
-      this.config.harm -= dpVal;
+  },
+  /** 结算奖励 */
+  async settlement(tempData, overInfo, session) {
+    const allList = [...tempData.self, ...tempData.goal].filter((item) => item.type == "玩家");
+    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、5货币");
+        for (const agent of allList) {
+          aynchronize(agent);
+          if (agent.for == "self") {
+            if (agent.hp <= 0) {
+              User.userTempData[agent.userId].hp = 0;
+              User.userTempData[agent.userId].isDie = true;
+            }
+            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
+            await User.giveMonetary(agent.userId, 5);
+          }
+        }
+      } else if (overInfo.win == "goal") {
+        await session.send("防御方获得20EXP、5货币");
+        for (const agent of allList) {
+          aynchronize(agent);
+          if (agent.for == "goal") {
+            if (agent.hp <= 0) {
+              User.userTempData[agent.userId].hp = 0;
+              User.userTempData[agent.userId].isDie = true;
+            }
+            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
+            await User.giveMonetary(agent.userId, 5);
+          }
+        }
+      }
     } else {
-      this.config.isBadDef = true;
-      this.config.harm = 1;
+      let val = 0;
+      let monetary = 0;
+      let props = [];
+      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) {
+          val += Math.floor(monster.giveExp + monster.giveExp * (item.lv - 1) * 0.2);
+          monetary += Math.floor(monster.giveMonetary + monster.giveExp * (item.lv - 1) * 0.1);
+          monster.giveProps?.forEach((propsItem) => {
+            if (item.lv >= (propsItem.lv || 1) && random(0, 100) < propsItem.radomVal) {
+              props.push({
+                name: propsItem.name,
+                val: propsItem.const ? propsItem.val : random(1, propsItem.val)
+              });
+            }
+          });
+        }
+      });
+      await session.send(`小队获得${val}EXP、${monetary}货币！`);
+      for (const agent of selfList) {
+        aynchronize(agent);
+        if (overInfo.win == "self") {
+          await User.giveExp(agent.userId, val, async (val2) => await msg(val2));
+          await User.giveMonetary(agent.userId, monetary);
+          props.length && await User.giveProps(agent.userId, props, async (val2) => {
+            const propsDict = {};
+            val2.currentProps.forEach((item) => {
+              if (!propsDict[item.name]) propsDict[item.name] = 1;
+              propsDict[item.name]++;
+            });
+            const msg2 = Object.keys(propsDict).map((item) => {
+              return `${item} ${propsDict[item]}个`;
+            }).join("\n");
+            await session.send(`${agent.name}在战斗中获得：` + msg2);
+          });
+        }
+      }
     }
-    return this;
-  }
-  result(fn) {
-    this.before((val) => {
-      fn?.before && fn.before(val);
-    }).beforRealHarm((val) => {
-      fn?.beforRealHarm && fn.beforRealHarm(val);
-    }).evasion((val) => {
-      fn?.evasion && fn.evasion(val);
-    }).csp((val) => {
-      fn?.csp && fn.csp(val);
-    }).beforDef((val) => {
-      fn?.beforDef && fn.beforDef(val);
-    });
-    return this.config;
   }
 };
-function giveDamage(self, goal, damage) {
-  if (goal.hp - damage.harm > 0) {
-    goal.hp -= damage.harm;
-    return damage.harm;
-  } else {
-    const lostHp = goal.hp;
-    goal.hp = 0;
-    return lostHp;
-  }
+function getLineupName(agent) {
+  return `[${agent.type}]${agent.name}`;
 }
-__name(giveDamage, "giveDamage");
-function giveCure(goal, val) {
-  const upVal = goal.hp + val;
-  if (upVal < goal.maxHp + goal.gain.maxHp) {
-    goal.hp = upVal;
-    return val;
+__name(getLineupName, "getLineupName");
+function initBattleAttribute(data) {
+  if ("playName" in data) {
+    const userData = data;
+    const temp = {
+      userId: userData.userId,
+      name: userData.playName,
+      lv: userData.lv,
+      type: "玩家",
+      hp: userData.hp,
+      maxHp: userData.maxHp,
+      mp: userData.mp,
+      maxMp: userData.maxMp,
+      atk: userData.atk,
+      def: userData.def,
+      chr: userData.chr,
+      ghd: userData.ghd,
+      csr: userData.csr,
+      evasion: userData.evasion,
+      hit: userData.hit,
+      speed: userData.speed,
+      gain: {
+        maxHp: 0,
+        maxMp: 0,
+        atk: 0,
+        def: 0,
+        chr: 0,
+        ghd: 0,
+        evasion: 0,
+        hit: 0,
+        speed: 0
+      },
+      buff: [],
+      fn: []
+    };
+    return temp;
   } else {
-    const abHp = goal.maxHp + goal.gain.maxHp - goal.hp;
-    goal.hp += abHp;
-    return abHp;
+    const monsterData2 = data;
+    const temp = {
+      name: monsterData2.name,
+      type: "怪物",
+      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: monsterData2.csr,
+      evasion: monsterData2.evasion,
+      hit: monsterData2.hit,
+      speed: monsterData2.speed,
+      gain: {
+        maxHp: 0,
+        maxMp: 0,
+        atk: 0,
+        def: 0,
+        chr: 0,
+        ghd: 0,
+        evasion: 0,
+        hit: 0,
+        speed: 0
+      },
+      buff: [],
+      fn: []
+    };
+    return temp;
   }
 }
-__name(giveCure, "giveCure");
-function moreDamageInfo(damage) {
-  return (damage.isCsp ? `（暴击！）` : "") + (damage.isEvasion ? `（闪避成功！）` : "") + (damage.isBadDef ? `（未破防！）` : "");
-}
-__name(moreDamageInfo, "moreDamageInfo");
+__name(initBattleAttribute, "initBattleAttribute");
 
-// 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")
+// src/users.ts
+var UserOccDict = {
+  ["剑士" /* 剑士 */]: {
+    info: "擅长近战攻击，拥有强大的属性能力",
+    initStatus: {
+      userId: "",
+      playName: "",
+      type: "剑士" /* 剑士 */,
+      exp: 0,
+      maxExp: 100,
+      lv: 1,
+      hp: 120,
+      maxHp: 120,
+      mp: 80,
+      maxMp: 80,
+      pp: 100,
+      maxPp: 100,
+      atk: 12,
+      def: 5,
+      chr: 50,
+      csr: 0,
+      ghd: 1.2,
+      speed: 5,
+      evasion: 100,
+      hit: 100
+    }
   },
-  "初级治愈": {
-    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")
+  ["法师" /* 法师 */]: {
+    info: "精通元素魔法，能够打出爆发伤害",
+    initStatus: {
+      userId: "",
+      playName: "",
+      type: "法师" /* 法师 */,
+      exp: 0,
+      maxExp: 100,
+      lv: 1,
+      hp: 100,
+      maxHp: 100,
+      mp: 100,
+      maxMp: 100,
+      pp: 100,
+      maxPp: 100,
+      atk: 10,
+      def: 2,
+      chr: 50,
+      csr: 0,
+      ghd: 1.2,
+      speed: 5,
+      evasion: 100,
+      hit: 100
+    }
+  },
+  ["刺客" /* 刺客 */]: {
+    info: "迅捷攻击，高闪避值的高敏玩家",
+    initStatus: {
+      userId: "",
+      playName: "",
+      type: "刺客" /* 刺客 */,
+      exp: 0,
+      maxExp: 100,
+      lv: 1,
+      hp: 90,
+      maxHp: 90,
+      mp: 70,
+      maxMp: 70,
+      pp: 100,
+      maxPp: 100,
+      atk: 8,
+      def: 2,
+      chr: 80,
+      csr: 0,
+      ghd: 1.3,
+      speed: 6,
+      evasion: 120,
+      hit: 100
+    }
   }
 };
-
-// src/battle.ts
-var BattleData = {
+var User = {
   config: {},
   ctx: {},
-  historyTemp: {},
-  lastPlay: {},
-  teamTemp: {},
-  init(config, ctx) {
-    this.config = config;
-    this.ctx = ctx;
-  },
-  /** 玩家是否正在战斗 */
-  isBattle(session) {
-    return !!BattleData.lastPlay[session.userId];
-  },
-  /** 玩家是否正在战斗 */
-  isBattleByUserId(userId) {
-    return !!BattleData.lastPlay[userId];
-  },
-  /** 玩家是否在队伍中 */
-  isTeam(session) {
-    return !!BattleData.teamTemp[session.userId];
-  },
-  isTeamByUserId(userId) {
-    return !!BattleData.teamTemp[userId];
+  userTempData: {},
+  async init(config, ctx) {
+    User.config = config;
+    User.ctx = ctx;
+    ctx.model.extend(
+      "smm_gensokyo_user_attribute",
+      {
+        userId: "string",
+        playName: "string",
+        type: "string",
+        exp: "integer",
+        lv: "integer",
+        hp: "integer",
+        mp: "integer",
+        pp: "integer",
+        isDie: "boolean"
+      },
+      {
+        primary: "userId",
+        autoInc: false
+      }
+    );
+    const userData = await ctx.database.get("smm_gensokyo_user_attribute", {});
+    const temp = {};
+    userData.forEach((item) => {
+      temp[item.userId] = item;
+    });
+    User.userTempData = temp;
   },
-  // 返回队伍信息
-  teamListByUser(userId) {
-    const teamList = [];
-    if (!BattleData.teamTemp[userId]) {
-      return [];
+  /** 获取角色基础属性 */
+  async getUserAttribute(session) {
+    if (!User.userTempData[session.userId]) {
+      await session.send("未创建账户，请发送 /开始注册 完成账号的注册！");
+      return null;
     }
-    const _userId = BattleData.teamTemp[userId].for;
-    Object.keys(BattleData.teamTemp).forEach((item) => {
-      if (BattleData.teamTemp[item].for == _userId) {
-        teamList.push(User.getUserAttributeByUserId(item));
+    return User.getUserAddLvAttribute(session.userId);
+  },
+  /** 获取角色实际等级属性数据 */
+  getUserAddLvAttribute(userId) {
+    const UserDict = User.userTempData[userId];
+    if (!UserDict) return null;
+    const UserData = {
+      ...UserOccDict[UserDict.type].initStatus,
+      lv: UserDict.lv,
+      hp: UserDict.hp,
+      mp: UserDict.mp,
+      exp: UserDict.exp,
+      pp: UserDict.pp,
+      playName: UserDict.playName,
+      userId: UserDict.userId
+    };
+    const lv = UserData.lv;
+    const temp = {};
+    const lvScope = Object.keys(userBenchmark).reverse().find((item) => Number(item) < lv) || 10;
+    const useBenchmark = userBenchmark[lvScope];
+    Object.keys(UserData).forEach((i) => {
+      temp[i] = UserData[i];
+      if (useBenchmark[i]) {
+        if (i == "maxExp") {
+          temp[i] = Math.floor(100 * useBenchmark[i] * (lv - 1)) || 100;
+        } else {
+          temp[i] += Math.floor(temp[i] * (useBenchmark[i] - 1) * (lv - 1));
+        }
       }
     });
-    return teamList;
+    return temp;
   },
-  /** 创建战斗-与怪物 */
-  async createBattleByMonster(session, goal) {
-    if (BattleData.isBattle(session)) {
-      await session.send("当前正在战斗，还不能逃脱！");
+  /** 通过 userId 获取角色属性 */
+  getUserAttributeByUserId(userId) {
+    return User.getUserAddLvAttribute(userId) || null;
+  },
+  /** 创建游戏账号 */
+  async createPlayUser(session) {
+    const [data] = await User.ctx.database.get("smm_gensokyo_user_attribute", { userId: session.userId });
+    if (data) {
+      await session.send("已存在账号，请勿重复创建！");
       return;
     }
-    const battle_user = [];
-    const battle_monsterList = [];
-    const playUser = [];
-    if (BattleData.isTeam(session) && BattleData.teamTemp[session.userId].identity == "队员") {
-      await session.send("你不是队伍的队长，无法主动操作战斗！");
+    await session.send("请输入自己的游戏昵称：(60s)");
+    const playname = await session.prompt(6e4);
+    if (playname == void 0) return;
+    const [repeat] = await User.ctx.database.get("smm_gensokyo_user_attribute", { playName: playname.trim() });
+    if (repeat) {
+      await session.send("名字重复，请更换一个名字。");
       return;
-    } else if (BattleData.isTeam(session)) {
-      Object.keys(BattleData.teamTemp).forEach((item) => {
-        if (BattleData.teamTemp[item].for == session.userId) {
-          playUser.push(item);
-          battle_user.push(initBattleAttribute(User.getUserAttributeByUserId(item)));
-        }
-      });
-    } else {
-      playUser.push(session.userId);
-      battle_user.push(initBattleAttribute(User.getUserAttributeByUserId(session.userId)));
     }
-    goal.forEach((item) => {
-      battle_monsterList.push(initBattleAttribute(Monster.getMonsterAttributeData(item.name, item.lv)));
-    });
+    if (playname.trim().length > 6 || playname.trim().length < 1) {
+      await session.send("名字长度有问题，要求小于 6个字，大于 1个字");
+      return;
+    }
+    await session.send(`请输入要专职的职业：（60s）
+${Object.keys(UserOccDict).map((i) => `【${i}】:${UserOccDict[i].info}`).join("\n")}`);
+    let jobType = await session.prompt(6e4);
+    if (jobType == void 0) return;
+    while (!Object.keys(UserOccDict).includes(jobType)) {
+      await session.send("未找到该职业，请重新选择！");
+      jobType = await session.prompt(6e4);
+    }
+    const temp = {
+      userId: session.userId,
+      playName: playname.trim(),
+      type: jobType,
+      hp: UserOccDict[jobType].initStatus.hp,
+      pp: UserOccDict[jobType].initStatus.pp,
+      mp: UserOccDict[jobType].initStatus.mp,
+      lv: 1,
+      exp: 0,
+      isDie: false
+    };
+    User.ctx.database.create("smm_gensokyo_user_attribute", temp);
+    User.userTempData[session.userId] = temp;
+    await Props.initUserPropsData(session.userId);
+    await session.send("创建成功！\n" + User.userAttributeTextFormat(session.userId));
+  },
+  /** 信息格式化 */
+  userAttributeTextFormat(userId) {
+    if (!User.userTempData[userId]) {
+      return "没有找到您的角色信息";
+    }
+    const temp = User.getUserAttributeByUserId(userId);
+    return `昵称：${temp.playName}
+职位：${temp.type}
+等级：${temp.lv} (${temp.exp}/${temp.maxExp})
+-----------------
+【生命值】${temp.hp}/${temp.maxHp}
+【魔法值】${temp.mp}/${temp.maxMp}
+【活力值】${temp.pp}/${temp.maxPp}
+-----------------
+【攻击力】${temp.atk} (+0)
+【防御力】${temp.def} (+0)
+【速度值】${temp.speed} (+0)
+【闪避值】${temp.evasion} (+0)
+【命中率】${(temp.hit / 10 + 100).toFixed(1)}% (+0%)
+【暴击率】${(temp.chr / 10).toFixed(1)}% (+0%)
+【暴击伤害】${(temp.ghd * 100).toFixed(1)}% (+0%)` + (temp.csr > 0 ? `
+【暴击抵抗】${temp.csr}` : "");
+  },
+  /** 写入用户数据到数据库 */
+  async setDatabaseUserAttribute(userId) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
     const temp = {
-      self: battle_user.map((i) => ({ ...i, for: "self" })),
-      goal: battle_monsterList.map((i) => ({ ...i, for: "goal" }))
+      playName: userInfo.playName.trim(),
+      hp: userInfo.hp,
+      pp: userInfo.pp,
+      mp: userInfo.mp,
+      lv: userInfo.lv,
+      exp: userInfo.exp
     };
-    playUser.forEach((userId) => {
-      BattleData.lastPlay[userId] = temp;
-    });
-    await session.send(`开始与 ${goal.map((i) => i.name).join("、")} 进行战斗`);
+    User.ctx.database.set("smm_gensokyo_user_attribute", { userId }, temp);
   },
-  /** 创建战斗-与玩家 */
-  async createBattleByUser(session, goal) {
-    if (BattleData.isBattle(session)) {
-      await session.send("当前正在战斗，还不能逃脱！");
-      return;
-    }
-    const battle_self = [];
-    const battle_goal = [];
-    const playUser = [];
-    const lostMsg = [];
-    goal = goal.filter((item) => {
-      const isBattle = BattleData.isBattleByUserId(item.userId);
-      const pyUser = User.userTempData[item.userId];
-      if (isBattle) {
-        lostMsg.push(`${pyUser.playName}正在参与着一场战斗，无法被PK选中。`);
-        return false;
-      }
-      return true;
-    });
-    if (lostMsg.length) {
-      await session.send(lostMsg.join("\n"));
-    }
-    if (!goal.length) {
-      lostMsg.push(`PK失败，无任何目标进行PK`);
-      return;
+  /** 给予玩家经验 */
+  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 (BattleData.isTeam(session) && BattleData.teamTemp[session.userId].identity == "队员") {
-      await session.send("你不是队伍的队长，无法主动操作战斗！");
-      return;
-    } else if (BattleData.isTeam(session)) {
-      Object.keys(BattleData.teamTemp).forEach((item) => {
-        if (BattleData.teamTemp[item].for == session.userId) {
-          playUser.push(item);
-          battle_self.push(initBattleAttribute(User.getUserAttributeByUserId(item)));
-        }
-      });
-    } else {
-      playUser.push(session.userId);
-      battle_self.push(initBattleAttribute(User.getUserAttributeByUserId(session.userId)));
+    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);
     }
-    goal.forEach((item) => {
-      playUser.push(item.userId);
-      battle_goal.push(initBattleAttribute(User.getUserAttributeByUserId(item.userId)));
-    });
-    const pkTemp = {
-      self: battle_self.map((i) => ({ ...i, for: "self" })),
-      goal: battle_goal.map((i) => ({ ...i, for: "goal" })),
-      isPK: true
-    };
-    playUser.forEach((userId) => {
-      BattleData.lastPlay[userId] = pkTemp;
-    });
-    await session.send(`开始与玩家 ${battle_goal.map((i) => i.name).join("、")} 进行PK战斗`);
+    await User.setDatabaseUserAttribute(userId);
   },
-  /** 文本化当前战况 */
-  battleSituationTextFormat(team) {
-    const selfTemp = [];
-    const goalTemp = [];
-    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})
-MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
-      } else {
-        selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
-      }
-    });
-    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})
-MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
-      } else {
-        goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
-      }
-    });
-    if (team.isPK) {
-      return `[当前战况]
-攻击方：
-` + selfTemp.join("\n") + "\n\n防御方：\n" + goalTemp.join("\n");
-    }
-    return `[当前战况]
-我方阵容：
-` + selfTemp.join("\n") + "\n\n敌方阵容：\n" + goalTemp.join("\n");
+  /** 给予玩家死亡 */
+  async giveDie(userId) {
+    const userInfo = User.userTempData[userId];
+    userInfo.hp = 0;
+    userInfo.isDie = true;
+    await User.setDatabaseUserAttribute(userId);
   },
-  /** 判断输赢 */
-  playOver(team) {
-    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: "平局", win: "" };
-    } else if (self) {
-      return { over: true, type: team.isPK ? "防御方赢" : "敌方赢", win: "goal" };
-    } else if (goal) {
-      return { over: true, type: team.isPK ? "攻击方赢" : "我方赢", win: "self" };
+  /** 给予玩家复活 */
+  async giveLife(userId, val) {
+    const userInfo = User.userTempData[userId];
+    if (!val) {
+      const { maxHp } = User.getUserAttributeByUserId(userId);
+      userInfo.hp = maxHp;
+    } else {
+      userInfo.hp = val;
     }
-    return { over: false, type: "未结束", win: "" };
-  },
-  /** 清理战场 */
-  clearBattleData(session) {
-    const currentBattle = BattleData.lastPlay[session.userId];
-    const allAgentList = [...currentBattle.goal, ...currentBattle.self];
-    allAgentList.forEach((item) => {
-      if (item.type == "玩家") {
-        delete BattleData.lastPlay[item.userId];
-      }
-    });
+    await User.setDatabaseUserAttribute(userId);
   },
-  async play(session, atkType, select) {
-    if (!BattleData.isBattle(session)) {
-      await session.send("您并没有任何参与战斗。");
+  /** 给予玩家血量或者蓝量 */
+  async giveHPMP(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    if (userInfo.isDie) {
+      fn && await fn({
+        currentHP: 0,
+        currentMP: 0,
+        err: "角色已死亡，无法使用恢复道具。"
+      });
       return;
     }
-    const currentBattle = BattleData.lastPlay[session.userId];
-    const allAgentList = [...currentBattle.goal, ...currentBattle.self].sort((a, b) => b.speed - a.speed);
-    const msgList = [];
-    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)];
+    if (BattleData.isBattleByUserId(userId)) {
+      const { goal, self } = BattleData.lastPlay[userId];
+      const agentAll = [...goal, ...self];
+      const agent = agentAll.find((item) => item?.userId == userId);
+      if (!agent) return;
+      if (agent.hp + (value.hp || 0) < agent.maxHp) {
+        agent.hp += value.hp || 0;
       } else {
-        selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+        agent.hp = agent.maxHp;
       }
-      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();
+      if (agent.mp + (value.mp || 0) < agent.maxMp) {
+        agent.mp += value.mp || 0;
       } 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();
-        }
+        agent.mp = agent.maxMp;
       }
+      fn && await fn({
+        currentHP: agent.hp,
+        currentMP: agent.mp
+      });
+      return;
     }
-    await session.send(msgList.length ? `战斗记录：
-` + msgList.join("\n") : "");
-    await session.send(BattleData.battleSituationTextFormat(currentBattle));
-    const result = BattleData.playOver(currentBattle);
-    if (result.over) {
-      await session.send(result.type);
-      await BattleData.settlement(currentBattle, result, session);
-      BattleData.clearBattleData(session);
+    const { maxHp, maxMp } = User.getUserAttributeByUserId(userId);
+    if (value.hp && !value.mp && userInfo.hp == maxHp) {
+      fn && await fn({
+        currentHP: userInfo.hp,
+        currentMP: userInfo.mp,
+        err: "当前血量已满，无需回复。"
+      });
+      return;
+    }
+    if (value.mp && !value.hp && userInfo.mp == maxMp) {
+      fn && await fn({
+        currentHP: userInfo.hp,
+        currentMP: userInfo.mp,
+        err: "当前蓝量已满，无需回复。"
+      });
+      return;
     }
+    if (value.mp && value.hp && userInfo.mp == maxMp && userInfo.hp == maxHp) {
+      fn && await fn({
+        currentHP: userInfo.hp,
+        currentMP: userInfo.mp,
+        err: "当前状态全满，无需回复。"
+      });
+      return;
+    }
+    if (userInfo.hp + (value.hp || 0) < maxHp) {
+      userInfo.hp += value.hp || 0;
+    } else {
+      userInfo.hp = maxHp;
+    }
+    if (userInfo.mp + (value.mp || 0) < maxHp) {
+      userInfo.mp += value.mp || 0;
+    } else {
+      userInfo.mp = maxMp;
+    }
+    fn && await fn({
+      currentHP: userInfo.hp,
+      currentMP: userInfo.mp
+    });
+    await User.setDatabaseUserAttribute(userId);
   },
-  /** 结算奖励 */
-  async settlement(tempData, overInfo, session) {
-    const allList = [...tempData.self, ...tempData.goal].filter((item) => item.type == "玩家");
-    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、5货币");
-        for (const agent of allList) {
-          aynchronize(agent);
-          if (agent.for == "self") {
-            if (agent.hp <= 0) {
-              User.userTempData[agent.userId].hp = 0;
-              User.userTempData[agent.userId].isDie = true;
-            }
-            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
-            await User.giveMonetary(agent.userId, 5);
-          }
-        }
-      } else if (overInfo.win == "goal") {
-        await session.send("防御方获得20EXP、5货币");
-        for (const agent of allList) {
-          aynchronize(agent);
-          if (agent.for == "goal") {
-            if (agent.hp <= 0) {
-              User.userTempData[agent.userId].hp = 0;
-              User.userTempData[agent.userId].isDie = true;
-            }
-            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
-            await User.giveMonetary(agent.userId, 5);
-          }
-        }
-      }
+  /** 给予玩家PP值 */
+  async givePP(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    const { maxPp } = User.getUserAttributeByUserId(userId);
+    if (userInfo.pp + value < maxPp) {
+      userInfo.pp += value;
     } else {
-      let val = 0;
-      let monetary = 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) {
-          val += Math.floor(monster.giveExp + monster.giveExp * (item.lv - 1) * 0.2);
-          monetary += Math.floor(monster.giveMonetary + monster.giveExp * (item.lv - 1) * 0.1);
-        }
+      userInfo.pp = maxPp;
+    }
+    fn && await fn({
+      currentPP: userInfo.pp
+    });
+    await User.setDatabaseUserAttribute(userId);
+  },
+  async lostPP(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    if (userInfo.pp - value < 0) {
+      fn && await fn({
+        currentPP: userInfo.pp,
+        err: "PP值不够，消耗失败！"
       });
-      await session.send(`小队获得${val}EXP、${monetary}货币！`);
-      for (const agent of selfList) {
-        aynchronize(agent);
-        if (overInfo.win == "self") {
-          await User.giveExp(agent.userId, val, async (val2) => await msg(val2));
-          await User.giveMonetary(agent.userId, monetary);
-        }
+      return;
+    }
+    userInfo.pp -= value;
+    fn && await fn({
+      currentPP: userInfo.pp
+    });
+    await User.setDatabaseUserAttribute(userId);
+  },
+  /** 给予玩家货币 */
+  async giveMonetary(userId, val, fn) {
+    const [bindData] = await User.ctx.database.get("binding", { pid: userId });
+    if (bindData && val) {
+      const [currentM] = await User.ctx.database.get("monetary", { uid: bindData.aid });
+      await User.ctx.monetary.gain(bindData.aid, val);
+      fn && await fn({ val, currentVal: currentM.value += val });
+    }
+  },
+  /** 收取玩家货币 */
+  async lostMonetary(userId, val, fn) {
+    const [bindData] = await User.ctx.database.get("binding", { pid: userId });
+    if (bindData && val) {
+      const [currentM] = await User.ctx.database.get("monetary", { uid: bindData.aid });
+      if (currentM.value - val < 0) {
+        fn && await fn({
+          val: Math.abs(val),
+          currentVal: currentM.value,
+          err: "余额不足！"
+        });
+        return;
       }
+      await User.ctx.monetary.cost(bindData.aid, val);
+      fn && await fn({
+        val: Math.abs(val),
+        currentVal: currentM.value - val
+      });
+    }
+  },
+  /** 给予玩家指定道具 */
+  async giveProps(userId, props, fn) {
+    const userProps = Props.userPorpsTemp[userId];
+    if (!userProps) return;
+    const upProps = [];
+    for (const item of props) {
+      const propsItem = propsData[item.name];
+      if (!propsItem) continue;
+      userProps[item.name] = {
+        name: propsItem.name,
+        type: propsItem.type,
+        value: 0
+      };
+      userProps[item.name].value += item.val || 1;
+      upProps.push({ name: item.name, val: userProps[item.name].value });
+    }
+    fn && await fn({
+      currentProps: upProps
+    });
+    await Props.setDatabasePropsData(userId);
+  },
+  /** 去除玩家指定道具 */
+  async loseProps(userId, props, fn) {
+    const userProps = Props.userPorpsTemp[userId];
+    const propsItem = propsData[props.name];
+    if (!userProps) return;
+    if (!propsItem) {
+      fn && await fn({
+        currentProps: { name: props.name, val: 0 },
+        err: "该道具信息不存在！"
+      });
+      return;
+    }
+    if (!userProps[props.name]) {
+      userProps[props.name] = {
+        name: propsItem.name,
+        type: propsItem.type,
+        value: 0
+      };
+    }
+    if (userProps[props.name].value - (props.val || 1) < 0) {
+      fn && await fn({
+        currentProps: { name: props.name, val: userProps[props.name].value },
+        err: `道具数量不足！剩余${userProps[props.name].value}个。`
+      });
+      return;
     }
+    userProps[props.name].value -= props.val || 1;
+    if (userProps[props.name].value == 0) delete userProps[props.name];
+    fn && await fn({
+      currentProps: { name: props.name, val: userProps[props.name]?.value || 0 }
+    });
+    await Props.setDatabasePropsData(userId);
+  },
+  /** 目标是否死亡 */
+  isDie(userId) {
+    return User.userTempData[userId]?.isDie;
   }
 };
-function getLineupName(agent) {
-  return `[${agent.type}]${agent.name}`;
-}
-__name(getLineupName, "getLineupName");
-function initBattleAttribute(data) {
-  if ("playName" in data) {
-    const userData = data;
-    const temp = {
-      userId: userData.userId,
-      name: userData.playName,
-      lv: userData.lv,
-      type: "玩家",
-      hp: userData.hp,
-      maxHp: userData.maxHp,
-      mp: userData.mp,
-      maxMp: userData.maxMp,
-      atk: userData.atk,
-      def: userData.def,
-      chr: userData.chr,
-      ghd: userData.ghd,
-      csr: userData.csr,
-      evasion: userData.evasion,
-      hit: userData.hit,
-      speed: userData.speed,
-      gain: {
-        maxHp: 0,
-        maxMp: 0,
-        atk: 0,
-        def: 0,
-        chr: 0,
-        ghd: 0,
-        evasion: 0,
-        hit: 0,
-        speed: 0
-      },
-      buff: [],
-      fn: []
-    };
-    return temp;
-  } else {
-    const monsterData2 = data;
-    const temp = {
-      name: monsterData2.name,
-      type: "怪物",
-      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: monsterData2.csr,
-      evasion: monsterData2.evasion,
-      hit: monsterData2.hit,
-      speed: monsterData2.speed,
-      gain: {
-        maxHp: 0,
-        maxMp: 0,
-        atk: 0,
-        def: 0,
-        chr: 0,
-        ghd: 0,
-        evasion: 0,
-        hit: 0,
-        speed: 0
-      },
-      buff: [],
-      fn: []
-    };
-    return temp;
-  }
-}
-__name(initBattleAttribute, "initBattleAttribute");
 
 // src/index.ts
 var name = "smmcat-gensokyo";
@@ -1786,10 +2021,22 @@ function apply(ctx, config) {
     await session.send(GensokyoMap.userAreaTextFormat(userData.playName, query));
   });
   ctx.command("幻想乡/个人属性").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     return `您的属性如下：
 ` + User.userAttributeTextFormat(session.userId);
   });
+  ctx.command("幻想乡/个人道具").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    return await Props.getPropsDataByUserId(session.userId);
+  });
   ctx.command("幻想乡/个人信息").userFields(["id"]).action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     const [data] = await ctx.database.get("monetary", { uid: session.user.id });
     return `[${User.userTempData[session.userId].playName}]：您当前货币为：${data?.value || 0}个`;
   });
@@ -1861,6 +2108,15 @@ function apply(ctx, config) {
       await BattleData.createBattleByUser(session, [{ userId: exist.userId }]);
     }
   });
+  ctx.command("幻想乡/道具使用 <props>").action(async ({ session }, props) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    if (!props) {
+      return `未选择道具使用，请选择道具，例如：/道具使用 红药`;
+    }
+    await Props.userProps(session, props);
+  });
   ctx.command("幻想乡/技能查询 <goal>").action(async ({ session }, goal) => {
     if (!goal) return `请输入技能名，例如 /技能查询 重砍`;
     if (!skillFn[goal]) return `没有存在 ${goal} 技能！`;