koishi-plugin-smmcat-gensokyo 0.0.1

package/lib/index.js

@@ -0,0 +1,1224 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+
+// src/map.ts
+var delay = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "delay");
+var GensokyoMap = {
+  config: {},
+  ctx: {},
+  mapLocalData: {},
+  userCurrentLoal: {},
+  async init(config, ctx) {
+    GensokyoMap.config = config;
+    GensokyoMap.ctx = ctx;
+    ctx.database.extend("smm_gensokyo_map_position", {
+      userId: "string",
+      floor: "integer",
+      areaName: "string",
+      moveing: "boolean",
+      playName: "string"
+    }, {
+      primary: "userId",
+      autoInc: false
+    });
+    GensokyoMap.mapLocalData = {
+      1: {
+        "地下墓穴": {
+          floor: 1,
+          areaName: "地下墓穴",
+          type: "BOSS区" /* BOSS区 */,
+          needLv: 1,
+          down: "蜘蛛洞穴"
+        },
+        "蜘蛛洞穴": {
+          floor: 1,
+          areaName: "蜘蛛洞穴",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          down: "蜘蛛森林一"
+        },
+        "蜘蛛森林一": {
+          floor: 1,
+          areaName: "蜘蛛森林一",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          monster: [{ name: "小蜘蛛", lv: 2 }],
+          top: "蜘蛛洞穴",
+          left: "蜘蛛森林二",
+          right: "蜘蛛森林三",
+          down: "蜘蛛森林通道"
+        },
+        "蜘蛛森林二": {
+          floor: 1,
+          areaName: "蜘蛛森林二",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          right: "蜘蛛森林一"
+        },
+        "蜘蛛森林三": {
+          floor: 1,
+          areaName: "蜘蛛森林三",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          left: "蜘蛛森林一"
+        },
+        "蜘蛛森林通道": {
+          floor: 1,
+          areaName: "蜘蛛森林通道",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "蜘蛛森林一",
+          down: "中央广场"
+        },
+        "中央广场": {
+          floor: 1,
+          areaName: "中央广场",
+          info: "一层的中心位置，梦开始的地方",
+          npc: ["aipo"],
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "蜘蛛森林通道",
+          down: "新手村",
+          left: "酒馆",
+          right: "银行"
+        },
+        "酒馆": {
+          floor: 1,
+          areaName: "酒馆",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          down: "传送门",
+          right: "中央广场"
+        },
+        "银行": {
+          floor: 1,
+          areaName: "银行",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          down: "1层-商店",
+          left: "中央广场"
+        },
+        "1层-商店": {
+          floor: 1,
+          areaName: "1层-商店",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          right: "农田",
+          left: "新手村"
+        },
+        "传送门": {
+          floor: 1,
+          areaName: "传送门",
+          type: "传送门" /* 传送门 */,
+          needLv: 1,
+          top: "酒馆",
+          right: "新手村",
+          left: "爱之湖"
+        },
+        "爱之湖": {
+          floor: 1,
+          areaName: "传送门",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          right: "传送门"
+        },
+        "新手村": {
+          floor: 1,
+          areaName: "新手村",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "中央广场",
+          down: "绿野平原通道",
+          left: "传送门",
+          right: "1层-商店"
+        },
+        "绿野平原通道": {
+          floor: 1,
+          areaName: "绿野平原通道",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "新手村",
+          down: "绿野平原一"
+        },
+        "绿野平原一": {
+          floor: 1,
+          areaName: "绿野平原一",
+          type: "冒险区" /* 冒险区 */,
+          monster: [{ name: "小蜜蜂", lv: 1 }, { name: "dora", lv: 2 }],
+          needLv: 1,
+          top: "绿野平原通道",
+          left: "绿野平原二",
+          right: "绿野平原三",
+          down: "绿野平原四"
+        },
+        "绿野平原二": {
+          floor: 1,
+          areaName: "绿野平原二",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          right: "绿野平原一",
+          down: "绿野平原五"
+        },
+        "绿野平原三": {
+          floor: 1,
+          areaName: "绿野平原三",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          left: "绿野平原一",
+          down: "绿野平原六"
+        },
+        "绿野平原四": {
+          floor: 1,
+          areaName: "绿野平原四",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "绿野平原一",
+          down: "野猪巢穴"
+        },
+        "绿野平原六": {
+          floor: 1,
+          areaName: "绿野平原六",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          left: "绿野平原四",
+          top: "绿野平原三"
+        },
+        "野猪巢穴": {
+          floor: 1,
+          areaName: "野猪巢穴",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "绿野平原四"
+        }
+      }
+    };
+    console.log(JSON.stringify(GensokyoMap.mapLocalData));
+    const userPoistionList = await ctx.database.get("smm_gensokyo_map_position", {});
+    const poistionTemp = {};
+    userPoistionList.forEach((poistion) => {
+      poistionTemp[poistion.userId] = poistion;
+    });
+    GensokyoMap.userCurrentLoal = poistionTemp;
+  },
+  /** 获取层的数据 */
+  getBaseFloorLocal(floor) {
+    return GensokyoMap.mapLocalData[floor] || null;
+  },
+  /** 获取用户当前区域信息 */
+  getUserCurrentArea(userid) {
+    const { floor, areaName } = GensokyoMap.userCurrentLoal[userid] || {};
+    if (!(floor && areaName)) return null;
+    return GensokyoMap.mapLocalData[floor][areaName] || null;
+  },
+  /** 初始化用户位置 */
+  initUserPoistion(session, userData) {
+    if (!GensokyoMap.userCurrentLoal[session.userId]) {
+      GensokyoMap.userCurrentLoal[session.userId] = {
+        userId: session.userId,
+        floor: 1,
+        areaName: "传送门",
+        moveing: false,
+        playName: userData.playName
+      };
+    }
+    GensokyoMap.setLocalStoragePoistionData(session.userId);
+  },
+  /** 位置信息存储到数据库 */
+  async setLocalStoragePoistionData(userId) {
+    const poistionData = { ...GensokyoMap.userCurrentLoal[userId] };
+    if (poistionData) {
+      const [localData] = await GensokyoMap.ctx.database.get("smm_gensokyo_map_position", { userId });
+      if (!localData) {
+        await GensokyoMap.ctx.database.create("smm_gensokyo_map_position", poistionData);
+        return;
+      }
+      delete poistionData.userId;
+      await GensokyoMap.ctx.database.set("smm_gensokyo_map_position", { userId }, poistionData);
+    }
+  },
+  /** 用户移动 */
+  async move(session, type, fn) {
+    const userCurrentArea = GensokyoMap.userCurrentLoal[session.userId] || {};
+    const { floor, areaName, moveing } = userCurrentArea;
+    if (moveing) {
+      await session.send("当前移动冷却中，请稍等...");
+      return;
+    }
+    if (!(floor && areaName)) {
+      await session.send("您当前位置有误，请使用(还没写好的指令)脱离卡死...");
+      return;
+    }
+    userCurrentArea.moveing = true;
+    const nowPosition = GensokyoMap.mapLocalData[floor][areaName];
+    if (!nowPosition[type]) {
+      await session.send("抱歉，此路不通！");
+      userCurrentArea.moveing = false;
+      return;
+    }
+    const newArea = GensokyoMap.mapLocalData[floor][nowPosition[type]];
+    if (!newArea) {
+      await session.send("进入失败，地图中不存在 " + nowPosition[type] + " 这个区域。");
+      userCurrentArea.moveing = false;
+      return;
+    }
+    if (newArea.type == "禁用" /* 禁用 */) {
+      await session.send(`该区域暂时未开放...`);
+      userCurrentArea.moveing = false;
+      return;
+    }
+    if (newArea.needLv > 1) {
+      await session.send(`当前区域由于您的等级未达到最低要求，暂时无法进入。
+需要等级：${newArea.needLv}级`);
+      userCurrentArea.moveing = false;
+      return;
+    }
+    userCurrentArea.areaName = newArea.areaName;
+    const areaInfo = {
+      user: { ...userCurrentArea },
+      map: { ...newArea }
+    };
+    fn && await fn(areaInfo);
+    await delay(3e3);
+    GensokyoMap.setLocalStoragePoistionData(session.userId);
+    userCurrentArea.moveing = false;
+    return;
+  },
+  /** 区域信息格式化 */
+  userAreaTextFormat(gameName, data) {
+    const liveUser = [];
+    Object.keys(GensokyoMap.userCurrentLoal).forEach((userId) => {
+      const areaItem = GensokyoMap.userCurrentLoal[userId];
+      if (areaItem.areaName == data.map.areaName && areaItem.floor == data.map.floor) {
+        if (gameName !== areaItem.playName) {
+          liveUser.push(areaItem.playName);
+        }
+      }
+    });
+    const str = `${gameName}[萌新] 当前位置：
+`;
+    const mapInfo = `区域：【${data.map.areaName}】
+` + (data.map.info ? data.map.info + "\n\n" : "\n") + (data.map.top ? `上：【${data.map.top}】
+` : "") + (data.map.down ? `下：【${data.map.down}】
+` : "") + (data.map.left ? `左：【${data.map.left}】
+` : "") + (data.map.right ? `右：【${data.map.right}】
+` : "") + (data.map.type == "传送门" /* 传送门 */ ? `
+[!]传送门区域` : "") + (data.map.shopName ? `
+[!]存在商店：${data.map.shopName}` : "") + (data.map.npc ? `
+[!]存在npc：${data.map.npc.join("、")}` : "") + (data.map.monster ? `
+[!]存在野怪：${data.map.monster.map((i) => `lv.${i.lv} ${i.name}`).join("、")}` : "") + (liveUser.length ? `
+[!]区域玩家：${liveUser.length > 3 ? liveUser.slice(0, 3).join("、") + `...等${liveUser.length}` : liveUser.join("、")}` : "");
+    return str + mapInfo;
+  }
+};
+
+// 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,
+      ghd: 1.2,
+      speed: 5,
+      evasion: 100,
+      hit: 1e3
+    }
+  },
+  ["法师" /* 法师 */]: {
+    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,
+      ghd: 1.2,
+      speed: 5,
+      evasion: 100,
+      hit: 1e3
+    }
+  },
+  ["刺客" /* 刺客 */]: {
+    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,
+      ghd: 1.3,
+      speed: 6,
+      evasion: 120,
+      hit: 1e3
+    }
+  }
+};
+var User = {
+  config: {},
+  ctx: {},
+  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"
+      },
+      {
+        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;
+  },
+  /** 获取角色基础属性 */
+  async getUserAttribute(session) {
+    if (!User.userTempData[session.userId]) {
+      await session.send("未创建账户，请发送 /开始注册 完成账号的注册！");
+      return null;
+    }
+    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,
+      exp: UserDict.exp,
+      pp: UserDict.pp,
+      playName: UserDict.playName,
+      userId: UserDict.userId
+    };
+    const lv = UserData.lv;
+    const benchmark = {
+      10: {
+        hp: 1.4,
+        maxHp: 1.4,
+        mp: 1.2,
+        maxMp: 1.2,
+        atk: 1.2,
+        def: 1.1,
+        chr: 1.1,
+        evasion: 1.2,
+        hit: 1.2,
+        ghd: 1,
+        speed: 1.05
+      },
+      20: {
+        hp: 1.35,
+        maxHp: 1.35,
+        mp: 1.1,
+        maxMp: 1.1,
+        atk: 1.1,
+        def: 1.1,
+        chr: 1.1,
+        evasion: 1.1,
+        hit: 1.1,
+        ghd: 1,
+        speed: 1.05
+      },
+      40: {
+        hp: 1.2,
+        maxHp: 1.2,
+        mp: 1.05,
+        maxMp: 1.05,
+        atk: 1.1,
+        def: 1.05,
+        chr: 1.05,
+        evasion: 1.05,
+        hit: 1.05,
+        ghd: 1.05,
+        speed: 1.05
+      }
+    };
+    const temp = {};
+    const lvScope = Object.keys(benchmark).reverse().find((item) => Number(item) < lv) || 10;
+    const useBenchmark = benchmark[lvScope];
+    Object.keys(UserData).forEach((i) => {
+      temp[i] = UserData[i];
+      if (useBenchmark[i]) {
+        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;
+    }
+    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;
+    }
+    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
+    };
+    User.ctx.database.create("smm_gensokyo_user_attribute", temp);
+    User.userTempData[session.userId] = temp;
+    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.hit} (+0)
+【速度值】${temp.speed} (+0)
+【闪避值】${temp.evasion} (+0)
+【暴击率】${(temp.chr / 10).toFixed(1)}% (+0%)
+【暴击伤害】${(temp.ghd * 100).toFixed(1)}% (+0%)`;
+  }
+};
+
+// 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
+      }
+    );
+    const monsterData = await ctx.database.get("smm_gensokyo_monster_attribute", {});
+    if (monsterData.length == 0) {
+      Monster.monsterTempData = Monster._createInitMonsterData();
+    } else {
+      const temp = {};
+      monsterData.forEach((item) => {
+        temp[item.id] = item;
+      });
+      Monster.monsterTempData = temp;
+    }
+  },
+  /** 赋予原始的怪物数据 */
+  _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) {
+    const monster = Monster.monsterTempData[monsterName];
+    if (!monster) return null;
+    const benchmark = {
+      10: {
+        hp: 1.4,
+        maxHp: 1.4,
+        mp: 1.2,
+        maxMp: 1.2,
+        atk: 1.2,
+        def: 1.1,
+        chr: 1.1,
+        evasion: 1.2,
+        hit: 1.2,
+        ghd: 1,
+        speed: 1.05
+      },
+      20: {
+        hp: 1.35,
+        maxHp: 1.35,
+        mp: 1.1,
+        maxMp: 1.1,
+        atk: 1.1,
+        def: 1.1,
+        chr: 1.1,
+        evasion: 1.1,
+        hit: 1.1,
+        ghd: 1,
+        speed: 1.05
+      },
+      40: {
+        hp: 1.2,
+        maxHp: 1.2,
+        mp: 1.05,
+        maxMp: 1.05,
+        atk: 1.1,
+        def: 1.05,
+        chr: 1.05,
+        evasion: 1.05,
+        hit: 1.05,
+        ghd: 1.05,
+        speed: 1.05
+      }
+    };
+    const temp = { lv };
+    const lvScope = Object.keys(benchmark).reverse().find((item) => Number(item) < lv) || 10;
+    const useBenchmark = benchmark[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));
+      }
+    });
+    return temp;
+  },
+  /** 格式化怪物属性数据 */
+  monsterAttributeTextFormat(monster) {
+    const { name: name2, type, lv, hp, maxHp, mp, maxMp, atk, def, chr, evasion, hit, ghd, speed, info } = monster;
+    const attributeText = `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: agent.self.atk + agent.self.gain.atk,
+      isRealHarm: realHarm,
+      isEvasion: false,
+      isCsp: false,
+      isBadDef: false
+    };
+  }
+  /** 伤害判定前 */
+  before(fn) {
+    fn && fn(this.config);
+    return this;
+  }
+  /** 真实伤害判定 */
+  beforRealHarm(fn) {
+    fn && fn(this.config);
+    if (this.config.isEvasion) {
+      this.config.harm = this.config.default_harm;
+    }
+    return this;
+  }
+  /** 是否闪避判定 */
+  evasion(fn) {
+    const { self, goal } = this.config.agent;
+    if (this.config.isRealHarm) return this;
+    const evaVal = (goal.evasion - (self.hit - 1e3)) / 10;
+    if (random(0, 100) <= evaVal) {
+      this.config.isEvasion = true;
+      fn && fn(this.config);
+      return this;
+    }
+    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 - goal.csr) / 10;
+    if (random(0, 100) <= cspVal) {
+      this.config.isCsp = true;
+      this.config.harm = Math.floor(this.config.default_harm * self.ghd);
+      fn && fn(this.config);
+      return this;
+    }
+    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;
+    fn && fn(this.config);
+    if (this.config.harm - dpVal > 0) {
+      this.config.harm -= dpVal;
+    } else {
+      this.config.isBadDef = true;
+      this.config.harm = 1;
+    }
+    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");
+
+// src/battle.ts
+var BattleData = {
+  config: {},
+  ctx: {},
+  historyTemp: {},
+  lastPlay: {},
+  teamTemp: {},
+  init(config, ctx) {
+    this.config = config;
+    this.ctx = ctx;
+  },
+  /** 玩家是否正在战斗 */
+  isBattle(session) {
+    return !!BattleData.lastPlay[session.userId];
+  },
+  /** 玩家是否在队伍中 */
+  isTeam(session) {
+    return !!BattleData.teamTemp[session.userId];
+  },
+  /** 创建战斗-与怪物 */
+  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 {
+      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)));
+    });
+    playUser.forEach((userId) => {
+      BattleData.lastPlay[userId] = {
+        self: battle_user.map((i) => ({ ...i, for: "self" })),
+        goal: battle_monsterList.map((i) => ({ ...i, for: "goal" }))
+      };
+    });
+    await session.send(`开始与 ${goal.map((i) => i.name).join("、")} 进行战斗`);
+    console.log(BattleData.lastPlay[session.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})`);
+      } 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})`);
+      } else {
+        goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
+      }
+    });
+    return `[当前战况]
+我方阵容：
+` + selfTemp.join("\n") + "\n\n敌方阵容：\n" + goalTemp.join("\n");
+  },
+  /** 判断输赢 */
+  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: "平局" };
+    } else if (self) {
+      return { over: true, type: "敌方赢" };
+    } else if (goal) {
+      return { over: true, type: "我方赢" };
+    }
+    return { over: false, type: "未结束" };
+  },
+  /** 清理战场 */
+  clearBattleData(session) {
+    if (BattleData.isTeam(session)) {
+      const userId = BattleData.teamTemp[session.userId].for;
+      Object.keys(BattleData.teamTemp).forEach((item) => {
+        if (BattleData.teamTemp[item].for == userId) {
+          delete BattleData.lastPlay[item];
+        }
+      });
+    } else {
+      delete BattleData.lastPlay[session.userId];
+    }
+  },
+  async play(session, atkType, select) {
+    if (!BattleData.isBattle(session)) {
+      await session.send("您并没有任何参与战斗。");
+      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 = [];
+      if (agent.for == "self") {
+        lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+      } else {
+        lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+      }
+      if (!lifeGoalList.length) continue;
+      let selectGoal = {};
+      let isMy = false;
+      if (agent.type == "玩家" && agent.userId == session.userId) {
+        isMy = true;
+        selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+      } else {
+        selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+      }
+      console.log(selectGoal);
+      const damageInfo = new Damage({ self: agent, goal: selectGoal }).result({
+        // 开始计算伤害前
+        before: /* @__PURE__ */ __name((val) => {
+          console.log(val);
+        }, "before"),
+        // 计算真实伤害前
+        beforRealHarm: /* @__PURE__ */ __name((val) => {
+          console.log(val);
+        }, "beforRealHarm"),
+        // 是否成功闪避
+        evasion: /* @__PURE__ */ __name((val) => {
+          console.log(val);
+        }, "evasion"),
+        // 是否成功暴击
+        csp: /* @__PURE__ */ __name((val) => {
+          console.log(val);
+        }, "csp"),
+        // 防御抵消前
+        beforDef: /* @__PURE__ */ __name((val) => {
+          console.log(val);
+        }, "beforDef")
+      });
+      giveDamage(agent, selectGoal, damageInfo);
+      msgList.push(
+        `[${agent.type}]${agent.name} 使用普攻攻击了 [${selectGoal.type}]${selectGoal.name}，造成了${damageInfo.harm}伤害。` + (damageInfo.isCsp ? `（暴击！）` : "") + (damageInfo.isEvasion ? `（闪避成功！）` : "") + (damageInfo.isBadDef ? `（未破防！）` : "")
+      );
+    }
+    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);
+      BattleData.clearBattleData(session);
+    }
+  }
+};
+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: 0,
+      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: []
+    };
+    return temp;
+  } else {
+    const monsterData = data;
+    const temp = {
+      name: monsterData.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,
+      csr: 0,
+      evasion: monsterData.evasion,
+      hit: monsterData.hit,
+      speed: monsterData.speed,
+      gain: {
+        maxHp: 0,
+        maxMp: 0,
+        atk: 0,
+        def: 0,
+        chr: 0,
+        ghd: 0,
+        evasion: 0,
+        hit: 0,
+        speed: 0
+      },
+      buff: []
+    };
+    return temp;
+  }
+}
+__name(initBattleAttribute, "initBattleAttribute");
+
+// src/index.ts
+var name = "smmcat-gensokyo";
+var inject = {
+  required: ["monetary", "database"]
+};
+var Config = import_koishi.Schema.object({});
+function apply(ctx, config) {
+  ctx.on("ready", () => {
+    GensokyoMap.init(config, ctx);
+    User.init(config, ctx);
+    Monster.init(config, ctx);
+  });
+  ctx.command("幻想乡");
+  ctx.command("幻想乡/移动.上").action(async ({ session }) => {
+    console.log(session.userId.slice(0, 6) + "触发了上移动");
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    GensokyoMap.move(session, "top" /* 上 */, async (val) => {
+      await session.send("移动成功...");
+      await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
+    });
+  });
+  ctx.command("幻想乡/移动.下").action(async ({ session }) => {
+    console.log(session.userId.slice(0, 6) + "触发了下移动");
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    GensokyoMap.move(session, "down" /* 下 */, async (val) => {
+      await session.send("移动成功...");
+      await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
+    });
+  });
+  ctx.command("幻想乡/移动.左").action(async ({ session }) => {
+    console.log(session.userId.slice(0, 6) + "触发了左移动");
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    GensokyoMap.move(session, "left" /* 左 */, async (val) => {
+      await session.send("移动成功...");
+      await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
+    });
+  });
+  ctx.command("幻想乡/移动.右").action(async ({ session }) => {
+    console.log(session.userId.slice(0, 6) + "触发了右移动");
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    GensokyoMap.move(session, "right" /* 右 */, async (val) => {
+      await session.send("移动成功...");
+      await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
+    });
+  });
+  ctx.command("幻想乡/位置").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    const query = {
+      user: GensokyoMap.userCurrentLoal[session.userId],
+      map: GensokyoMap.getUserCurrentArea(session.userId)
+    };
+    if (!query.map) {
+      return `无效区域`;
+    }
+    await session.send(GensokyoMap.userAreaTextFormat(userData.playName, query));
+  });
+  ctx.command("幻想乡/个人属性").action(async ({ session }) => {
+    return `您的属性如下：
+` + User.userAttributeTextFormat(session.userId);
+  });
+  ctx.command("幻想乡/开始注册").action(async ({ session }) => {
+    await User.createPlayUser(session);
+  });
+  ctx.command("幻想乡/查询怪物 <monster> <lv:posint>").action(async ({ session }, monster, lv) => {
+    if (!monster) return `请输入要查询的怪物！`;
+    if (!lv) lv = 1;
+    const result = Monster.getMonsterAttributeData(monster, lv);
+    if (!result) return `没有找到该怪物信息...`;
+    return `查找成功！
+` + Monster.monsterAttributeTextFormat(result);
+  });
+  ctx.command("幻想乡/打怪遇敌 <goal>").action(async ({ session }, goal) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    const areaInfo = GensokyoMap.getUserCurrentArea(session.userId);
+    if (goal) {
+      if (!areaInfo.monster.map((i) => i.name).includes(goal)) {
+        return `没有在该区域找到该怪物。`;
+      }
+      const selectMonster = areaInfo.monster.find((i) => i.name == goal);
+      await BattleData.createBattleByMonster(session, [selectMonster]);
+    } else {
+      const selectMonster = areaInfo.monster;
+      await BattleData.createBattleByMonster(session, selectMonster);
+    }
+  });
+  ctx.command("幻想乡/打怪攻击 <goal>").action(async ({ session }, goal) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    BattleData.play(session, "普攻", goal);
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});