koishi-plugin-smmcat-gensokyo 0.0.28 → 0.0.30

package/lib/index.js

@@ -28,429 +28,6 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 var import_koishi2 = 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: "蜘蛛洞穴",
-          monster: [{ name: "古明地觉", lv: 15 }]
-        },
-        "蜘蛛洞穴": {
-          floor: 1,
-          areaName: "蜘蛛洞穴",
-          type: "冒险区" /* 冒险区 */,
-          needLv: 1,
-          top: "地下墓穴",
-          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: "蜘蛛森林一",
-          monster: [{ name: "大妖精", lv: 3 }]
-        },
-        "蜘蛛森林通道": {
-          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: "冒险区" /* 冒险区 */,
-          monster: [{ name: "dora", lv: 2 }, { name: "dora", lv: 2 }, { name: "dora", lv: 3 }, { name: "dora", lv: 2 }],
-          needLv: 1,
-          right: "绿野平原一",
-          down: "绿野平原五"
-        },
-        "绿野平原三": {
-          floor: 1,
-          areaName: "绿野平原三",
-          type: "冒险区" /* 冒险区 */,
-          monster: [{ name: "dora", lv: 5 }],
-          needLv: 1,
-          left: "绿野平原一",
-          down: "绿野平原六"
-        },
-        "绿野平原四": {
-          floor: 1,
-          areaName: "绿野平原四",
-          type: "冒险区" /* 冒险区 */,
-          needLv: 1,
-          top: "绿野平原一",
-          down: "野猪巢穴",
-          left: "绿野平原五",
-          right: "绿野平原六",
-          monster: [{ name: "琪露诺", lv: 10 }]
-        },
-        "绿野平原五": {
-          floor: 1,
-          areaName: "绿野平原五",
-          type: "冒险区" /* 冒险区 */,
-          needLv: 1,
-          top: "绿野平原二",
-          right: "绿野平原四"
-        },
-        "绿野平原六": {
-          floor: 1,
-          areaName: "绿野平原六",
-          type: "冒险区" /* 冒险区 */,
-          needLv: 1,
-          left: "绿野平原四",
-          top: "绿野平原三",
-          monster: [{ name: "绿毒蛇", lv: 12 }]
-        },
-        "野猪巢穴": {
-          floor: 1,
-          areaName: "野猪巢穴",
-          type: "BOSS区" /* BOSS区 */,
-          needLv: 1,
-          top: "绿野平原四",
-          monster: [{ name: "蓬莱山辉夜", lv: 20 }]
-        }
-      },
-      2: {
-        "传送门": {
-          floor: 2,
-          areaName: "传送门",
-          type: "传送门" /* 传送门 */,
-          needLv: 1,
-          right: "希望之泉"
-        },
-        "希望之泉": {
-          floor: 2,
-          areaName: "希望之泉",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          top: "爱之湖",
-          down: "农田",
-          left: "传送门",
-          right: "2层-商店"
-        },
-        "爱之湖": {
-          floor: 2,
-          areaName: "爱之湖",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          down: "希望之泉",
-          right: "旅馆"
-        },
-        "农田": {
-          floor: 2,
-          areaName: "农田",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          top: "希望之泉",
-          right: "银行"
-        },
-        "银行": {
-          floor: 2,
-          areaName: "银行",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          top: "2层-商店",
-          left: "农田"
-        },
-        "旅馆": {
-          floor: 2,
-          areaName: "旅馆",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          down: "2层-商店",
-          left: "爱之湖"
-        },
-        "2层-商店": {
-          floor: 2,
-          areaName: "2层-商店",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          right: "大草场"
-        },
-        "大草场": {
-          floor: 2,
-          areaName: "大草场",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          left: "2层-商店",
-          right: "森林岔口"
-        },
-        "森林岔口": {
-          floor: 2,
-          areaName: "森林岔口",
-          type: "安全区" /* 安全区 */,
-          needLv: 1,
-          left: "大草场"
-        }
-      }
-    };
-    console.log(JSON.stringify(GensokyoMap.mapLocalData));
-    const userPoistionList = await ctx.database.get("smm_gensokyo_map_position", {});
-    const poistionTemp = {};
-    userPoistionList.forEach((poistion) => {
-      poistion.moveing = false;
-      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) {
-    try {
-      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);
-      userCurrentArea.moveing = false;
-      GensokyoMap.setLocalStoragePoistionData(session.userId);
-      return;
-    } catch (error) {
-      console.log(error);
-      if (GensokyoMap.userCurrentLoal?.[session.userId]) {
-        GensokyoMap.userCurrentLoal[session.userId].moveing = false;
-      }
-    }
-  },
-  /** 查询附近玩家 */
-  nearbyPlayersByUserId(userId) {
-    const areaData = GensokyoMap.getUserCurrentArea(userId);
-    const liveUser = [];
-    Object.keys(GensokyoMap.userCurrentLoal).forEach((_userId) => {
-      const userItem = GensokyoMap.userCurrentLoal[_userId];
-      if (userItem.areaName == areaData.areaName && userItem.floor == areaData.floor) {
-        if (userId !== userItem.userId) {
-          liveUser.push({ userId: userItem.userId, playName: userItem.playName });
-        }
-      }
-    });
-    return liveUser;
-  },
-  /** 区域信息格式化 */
-  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/data/benchmark.ts
 var monsterBenchmark = {
   10: {
@@ -1460,1229 +1037,1988 @@ var BattleData = {
   isTeamByUserId(userId) {
     return !!BattleData.teamTemp[userId];
   },
-  // 返回队伍信息
-  teamListByUser(userId) {
-    const teamList = [];
-    if (!BattleData.teamTemp[userId]) {
-      return [];
+  // 返回队伍信息
+  teamListByUser(userId) {
+    const teamList = [];
+    if (!BattleData.teamTemp[userId]) {
+      return [];
+    }
+    const _userId = BattleData.teamTemp[userId].for;
+    Object.keys(BattleData.teamTemp).forEach((item) => {
+      if (BattleData.teamTemp[item].for == _userId) {
+        teamList.push(User.getUserAttributeByUserId(item));
+      }
+    });
+    return teamList;
+  },
+  /** 创建队伍 */
+  async creatTeam(session) {
+    const { userId } = session;
+    if (BattleData.isTeamByUserId(userId)) {
+      await session.send(`${User.getUserName(userId)}:你已经加入了${BattleData.teamTemp[userId].for}的队伍，需要退出才可以重新创建！`);
+      return;
+    }
+    BattleData.teamTemp[userId] = {
+      for: userId,
+      identity: "队长"
+    };
+    await session.send("创建队伍成功！发送 /队伍邀请 昵称 \n可对周围对应昵称玩家进行组队邀请！");
+  },
+  /** 邀请加入队伍 */
+  async invitationTeam(session, playName) {
+    const { userId } = session;
+    if (!BattleData.isTeamByUserId(userId)) {
+      await session.send(`你还没有创建队伍，请发送 /队伍创建 创建队伍吧！`);
+      return;
+    }
+    const teamInfo = BattleData.teamTemp[userId];
+    if (teamInfo.identity !== "队长") {
+      await session.send(`你不是小队队长，无法邀请玩家加入！`);
+      return;
+    }
+    const nearUser = GensokyoMap.nearbyPlayersByUserId(userId);
+    const invitationUser = nearUser.find((item) => item.playName == playName);
+    if (!invitationUser) {
+      await session.send(`玩家${playName}不在你附近，邀请失败！`);
+      return;
+    }
+    if (BattleData.isTeamByUserId(invitationUser.userId)) {
+      await session.send(`对方已经组队，或者已经在队伍中！`);
+      return;
+    }
+    BattleData.invitationTemp[invitationUser.userId] = {
+      time: Date.now(),
+      for: userId,
+      playName: User.getUserName(userId),
+      seen: false
+    };
+    await session.send(`已经发送邀请，等待TA的 /队伍加入 操作`);
+  },
+  /** 加入队伍 */
+  async joinTeam(session) {
+    const { userId } = session;
+    if (!BattleData.invitationTemp[userId]) {
+      await session.send("当前最后记录中无人邀请你加入队伍...");
+      return;
+    }
+    if (BattleData.isTeamByUserId(userId)) {
+      await session.send(`你已经在队伍中，无法再次加入，若需要加入请发送 /队伍退出`);
+      return;
+    }
+    const invInfo = BattleData.invitationTemp[userId];
+    if (Date.now() - invInfo.time > 36e5) {
+      await session.send(`${invInfo.playName}的邀请队伍请求已超时！`);
+      delete BattleData.invitationTemp[userId];
+      return;
+    }
+    if (BattleData.teamListByUser(invInfo.for).length >= 4) {
+      await session.send(`${invInfo.playName}的队伍人员已满！无法加入`);
+      return;
+    }
+    BattleData.teamTemp[userId] = {
+      for: invInfo.for,
+      identity: "队员"
+    };
+    await session.send(`加入${invInfo.playName}的队伍成功！
+若后续需要退出可发送 /队伍退出`);
+  },
+  /** 退出队伍 */
+  async exitTeam(session) {
+    const { userId } = session;
+    if (!BattleData.isTeamByUserId(userId)) {
+      await session.send("你还没有加入任何队伍！");
+      return;
+    }
+    if (BattleData.teamTemp[userId].identity == "队长") {
+      await session.send("你是小队队长，无法退出。若要解散队伍，请发送 /队伍解散");
+      return;
+    }
+    const teamName = User.getUserName(BattleData.teamTemp[userId].for);
+    delete BattleData.teamTemp[userId];
+    await session.send(`退出${teamName}的小队成功！`);
+  },
+  /** 解散队伍 */
+  async dissolveTeam(session) {
+    const { userId } = session;
+    if (!BattleData.isTeamByUserId(userId)) {
+      await session.send("你还没有加入任何队伍！");
+      return;
+    }
+    if (BattleData.teamTemp[userId].identity == "队员") {
+      await session.send("你不是小队队长，无法解散。");
+      return;
+    }
+    const team = BattleData.teamListByUser(userId);
+    team.forEach((item) => {
+      delete BattleData.teamTemp[item.userId];
+    });
+    await session.send("操作成功，已经解散你创建的小队。");
+  },
+  /** 创建战斗-与怪物 */
+  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)));
+    });
+    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 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;
+    }
+    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战斗`);
+  },
+  /** 文本化当前战况 */
+  battleSituationTextFormat(team) {
+    const selfTemp = [];
+    const goalTemp = [];
+    const getBuffTemplate = /* @__PURE__ */ __name((agent) => {
+      const dict = { 1: "¹", 2: "²", 3: "³", 4: "⁴", 5: "⁵", 6: "⁶", 7: "⁷", 8: "⁸", 9: "⁹" };
+      const buffInfo = Object.keys(agent.buff).map((item) => {
+        return `${agent.buff[item].name}${dict[agent.buff[item].timer] || "⁺"}`;
+      });
+      return buffInfo.length ? "(" + buffInfo.join(" ") + ")" : "";
+    }, "getBuffTemplate");
+    team.self.forEach((item) => {
+      if (item.hp > 0) {
+        selfTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
+      } else {
+        selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
+      }
+    });
+    team.goal.forEach((item) => {
+      if (item.hp > 0) {
+        goalTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
+      } else {
+        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");
+  },
+  /** 判断输赢 */
+  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" };
     }
-    const _userId = BattleData.teamTemp[userId].for;
-    Object.keys(BattleData.teamTemp).forEach((item) => {
-      if (BattleData.teamTemp[item].for == _userId) {
-        teamList.push(User.getUserAttributeByUserId(item));
+    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];
       }
     });
-    return teamList;
   },
-  /** 创建队伍 */
-  async creatTeam(session) {
-    const { userId } = session;
-    if (BattleData.isTeamByUserId(userId)) {
-      await session.send(`${User.getUserName(userId)}:你已经加入了${BattleData.teamTemp[userId].for}的队伍，需要退出才可以重新创建！`);
+  async play(session, atkType, select) {
+    if (!BattleData.isBattle(session)) {
+      await session.send("您并没有任何参与战斗。");
       return;
     }
-    BattleData.teamTemp[userId] = {
-      for: userId,
-      identity: "队长"
-    };
-    await session.send("创建队伍成功！发送 /队伍邀请 昵称 \n可对周围对应昵称玩家进行组队邀请！");
-  },
-  /** 邀请加入队伍 */
-  async invitationTeam(session, playName) {
-    const { userId } = session;
-    if (!BattleData.isTeamByUserId(userId)) {
-      await session.send(`你还没有创建队伍，请发送 /队伍创建 创建队伍吧！`);
-      return;
+    const currentBattle = BattleData.lastPlay[session.userId];
+    const allAgentList = [...currentBattle.goal, ...currentBattle.self].sort((a, b) => b.speed + b.gain.speed - (a.speed + a.gain.speed));
+    const msgList = [];
+    for (const agent of allAgentList) {
+      const buffMsg = settlementBuff(agent);
+      buffMsg && msgList.push(buffMsg);
+      if (agent.hp <= 0) {
+        if (agent.type == "玩家" && !User.userTempData[agent.userId]?.isDie) {
+          User.userTempData[agent.userId].hp = 0;
+          User.userTempData[agent.userId].isDie = true;
+        }
+        continue;
+      }
+      if (!agent.gain.dizziness) {
+        let lifeGoalList = [];
+        let lifeSelfList = [];
+        if (agent.for == "self") {
+          lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+          lifeSelfList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+        } else {
+          lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+          lifeSelfList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+        }
+        if (!lifeGoalList.length) continue;
+        let selectGoal = {};
+        let isMy = false;
+        let funType = "普攻";
+        if (!agent.gain.chaos) {
+          if (agent.type == "玩家" && agent.userId == session.userId) {
+            isMy = true;
+            funType = atkType;
+            selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+          } else if (agent.type == "玩家") {
+            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+          } else {
+            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+            if (random(0, 10) < 4 && agent.fn?.length) {
+              funType = getSkillFn(agent.fn);
+            }
+          }
+        } else {
+          const fliteMyList = allAgentList.filter((item) => item.id !== agent.id && item.hp > 0);
+          if (!fliteMyList.length) continue;
+          selectGoal = fliteMyList[Math.random() * fliteMyList.length];
+        }
+        const noralAtk = /* @__PURE__ */ __name(() => {
+          const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
+          giveDamage(agent, selectGoal, damageInfo);
+          msgList.push(
+            `${getLineupName(agent)} 使用普攻攻击了 ${getLineupName(selectGoal)}，造成了${damageInfo.harm}伤害。` + moreDamageInfo(damageInfo)
+          );
+        }, "noralAtk");
+        if (funType == "普攻") {
+          noralAtk();
+        } else {
+          if (skillFn[funType]) {
+            let _selectGoal = selectGoal;
+            if (["治疗技" /* 治疗技 */, "增益技" /* 增益技 */].includes(skillFn[funType].type)) {
+              _selectGoal = lifeSelfList.find((item) => item.name == select) || agent;
+            }
+            const selectFn = skillFn[funType];
+            if (selectFn.mp == 0 || agent.mp - selectFn.mp >= 0) {
+              agent.mp -= selectFn.mp;
+              let isNext = false;
+              const fnMsg = selectFn.fn(
+                { self: agent, goal: _selectGoal },
+                { selfList: lifeSelfList, goalList: lifeGoalList },
+                (val) => {
+                  switch (val.type) {
+                    case "伤害技" /* 伤害技 */:
+                      val.target.map((goal) => {
+                        giveDamage(agent, goal, val.damage);
+                      });
+                      break;
+                    case "治疗技" /* 治疗技 */:
+                      val.target.map((goal) => {
+                        giveCure(goal, val.value);
+                      });
+                      break;
+                    case "增益技" /* 增益技 */:
+                      isMy && val.err && session.send(val.err);
+                      break;
+                    case "释放失败" /* 释放失败 */:
+                      isMy && val.err && session.send(val.err);
+                    default:
+                      break;
+                  }
+                  isNext = val.isNext;
+                }
+              );
+              fnMsg && msgList.push(fnMsg);
+              isNext && noralAtk();
+            } else {
+              isMy && await session.send(`MP不足，释放失败！`);
+              noralAtk();
+            }
+          } else {
+            isMy && await session.send(`未持有该技能或者该技能不存在，释放失败！`);
+            noralAtk();
+          }
+        }
+      }
     }
-    const teamInfo = BattleData.teamTemp[userId];
-    if (teamInfo.identity !== "队长") {
-      await session.send(`你不是小队队长，无法邀请玩家加入！`);
-      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 nearUser = GensokyoMap.nearbyPlayersByUserId(userId);
-    const invitationUser = nearUser.find((item) => item.playName == playName);
-    if (!invitationUser) {
-      await session.send(`玩家${playName}不在你附近，邀请失败！`);
-      return;
+  },
+  /** 结算奖励 */
+  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 > 0 ? agent.hp : 0;
+      User.userTempData[agent.userId].mp = agent.mp;
+      if (User.userTempData[agent.userId].hp <= 0) {
+        User.userTempData[agent.userId].isDie = true;
+      }
+    }, "aynchronize");
+    if (tempData.isPK) {
+      if (overInfo.win == "self") {
+        await session.send("攻击方获得20EXP、5货币");
+        for (const agent of allList) {
+          aynchronize(agent);
+          if (agent.for == "self") {
+            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") {
+            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
+            await User.giveMonetary(agent.userId, 5);
+          }
+        }
+      }
+    } else {
+      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)
+              });
+            }
+          });
+        }
+      });
+      if (overInfo.win == "self") {
+        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] = 0;
+              propsDict[item.name]++;
+            });
+            const msg2 = Object.keys(propsDict).map((item) => {
+              return `${item} ${propsDict[item]}个`;
+            }).join("\n");
+            await session.send(`${agent.name}在战斗中获得：` + msg2);
+          });
+        }
+      }
     }
-    if (BattleData.isTeamByUserId(invitationUser.userId)) {
-      await session.send(`对方已经组队，或者已经在队伍中！`);
-      return;
+  }
+};
+function getLineupName(agent) {
+  return `[${agent.type}]${agent.name}`;
+}
+__name(getLineupName, "getLineupName");
+function getSkillFn(fnList) {
+  const totalProb = fnList.reduce((sum, item) => sum + item.prob, 0);
+  const random2 = Math.random() * totalProb;
+  let currentProb = 0;
+  for (const item of fnList) {
+    currentProb += item.prob;
+    if (random2 < currentProb) {
+      return item.name;
     }
-    BattleData.invitationTemp[invitationUser.userId] = {
-      time: Date.now(),
-      for: userId,
-      playName: User.getUserName(userId),
-      seen: false
+  }
+  return fnList[fnList.length - 1].name;
+}
+__name(getSkillFn, "getSkillFn");
+function initBattleAttribute(data) {
+  if ("playName" in data) {
+    const userData = data;
+    const temp = {
+      id: Date.now(),
+      userId: userData.userId,
+      name: userData.playName,
+      lv: userData.lv,
+      type: "玩家",
+      selfType: userData.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,
+        chaos: false,
+        dizziness: false,
+        reduction: 0
+      },
+      buff: {},
+      fn: [],
+      expand: {}
     };
-    await session.send(`已经发送邀请，等待TA的 /队伍加入 操作`);
-  },
-  /** 加入队伍 */
-  async joinTeam(session) {
-    const { userId } = session;
-    if (!BattleData.invitationTemp[userId]) {
-      await session.send("当前最后记录中无人邀请你加入队伍...");
-      return;
-    }
-    if (BattleData.isTeamByUserId(userId)) {
-      await session.send(`你已经在队伍中，无法再次加入，若需要加入请发送 /队伍退出`);
-      return;
-    }
-    const invInfo = BattleData.invitationTemp[userId];
-    if (Date.now() - invInfo.time > 36e5) {
-      await session.send(`${invInfo.playName}的邀请队伍请求已超时！`);
-      delete BattleData.invitationTemp[userId];
-      return;
-    }
-    if (BattleData.teamListByUser(invInfo.for).length >= 4) {
-      await session.send(`${invInfo.playName}的队伍人员已满！无法加入`);
-      return;
-    }
-    BattleData.teamTemp[userId] = {
-      for: invInfo.for,
-      identity: "队员"
+    return temp;
+  } else {
+    const monsterData2 = data;
+    const temp = {
+      id: Date.now(),
+      name: monsterData2.name,
+      type: "怪物",
+      selfType: monsterData2.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,
+        chaos: false,
+        dizziness: false,
+        reduction: 0
+      },
+      buff: {},
+      fn: monsterData2.fn ? JSON.parse(JSON.stringify(monsterData2.fn)) : [],
+      expand: {}
     };
-    await session.send(`加入${invInfo.playName}的队伍成功！
-若后续需要退出可发送 /队伍退出`);
-  },
-  /** 退出队伍 */
-  async exitTeam(session) {
-    const { userId } = session;
-    if (!BattleData.isTeamByUserId(userId)) {
-      await session.send("你还没有加入任何队伍！");
-      return;
-    }
-    if (BattleData.teamTemp[userId].identity == "队长") {
-      await session.send("你是小队队长，无法退出。若要解散队伍，请发送 /队伍解散");
-      return;
-    }
-    const teamName = User.getUserName(BattleData.teamTemp[userId].for);
-    delete BattleData.teamTemp[userId];
-    await session.send(`退出${teamName}的小队成功！`);
-  },
-  /** 解散队伍 */
-  async dissolveTeam(session) {
-    const { userId } = session;
-    if (!BattleData.isTeamByUserId(userId)) {
-      await session.send("你还没有加入任何队伍！");
-      return;
-    }
-    if (BattleData.teamTemp[userId].identity == "队员") {
-      await session.send("你不是小队队长，无法解散。");
-      return;
-    }
-    const team = BattleData.teamListByUser(userId);
-    team.forEach((item) => {
-      delete BattleData.teamTemp[item.userId];
-    });
-    await session.send("操作成功，已经解散你创建的小队。");
-  },
-  /** 创建战斗-与怪物 */
-  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)));
+    return temp;
+  }
+}
+__name(initBattleAttribute, "initBattleAttribute");
+
+// src/data/initProps.ts
+var propsData = {
+  "红药": {
+    name: "红药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20HP",
+    price: 10,
+    fn: /* @__PURE__ */ __name(async 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);
       });
-    } 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)));
-    });
-    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("、")} 进行战斗`);
+    }, "fn")
   },
-  /** 创建战斗-与玩家 */
-  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;
-    }
-    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)));
+  "蓝药": {
+    name: "蓝药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20MP",
+    price: 10,
+    fn: /* @__PURE__ */ __name(async 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);
       });
-    } 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战斗`);
+    }, "fn")
   },
-  /** 文本化当前战况 */
-  battleSituationTextFormat(team) {
-    const selfTemp = [];
-    const goalTemp = [];
-    const getBuffTemplate = /* @__PURE__ */ __name((agent) => {
-      const dict = { 1: "¹", 2: "²", 3: "³", 4: "⁴", 5: "⁵", 6: "⁶", 7: "⁷", 8: "⁸", 9: "⁹" };
-      const buffInfo = Object.keys(agent.buff).map((item) => {
-        return `${agent.buff[item].name}${dict[agent.buff[item].timer] || "⁺"}`;
+  "初级万能药": {
+    name: "初级万能药",
+    type: "消耗类" /* 消耗类 */,
+    info: "回复自身20MP和20HP",
+    price: 20,
+    fn: /* @__PURE__ */ __name(async 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);
       });
-      return buffInfo.length ? "(" + buffInfo.join(" ") + ")" : "";
-    }, "getBuffTemplate");
-    team.self.forEach((item) => {
-      if (item.hp > 0) {
-        selfTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
-MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
-      } else {
-        selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
+    }, "fn")
+  },
+  "初级复活卷轴": {
+    name: "初级复活卷轴",
+    type: "消耗类" /* 消耗类 */,
+    info: "复活玩家，复活时保留 20% 血量。(该道具使用完需要冷却 6 分钟)",
+    price: 10,
+    cooling: 3600,
+    fn: /* @__PURE__ */ __name(async function(session) {
+      if (BattleData.isBattleByUserId(session.userId)) {
+        session.send(`该道具在战斗中无法使用！请在小队脱离战斗后使用。`);
+        return { err: true };
       }
-    });
-    team.goal.forEach((item) => {
-      if (item.hp > 0) {
-        goalTemp.push(`lv.${item.lv}[${item.name}]${getBuffTemplate(item)}:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
-MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
-      } else {
-        goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
+      if (!User.isDie(session.userId)) {
+        session.send(`您还没有阵亡，使用失败！`);
+        return { err: true };
       }
+      const { maxHp } = User.getUserAttributeByUserId(session.userId);
+      User.giveLife(session.userId, Math.floor(maxHp * 0.2), async (val) => {
+        await session.send(`复活成功，当前血量：${val.currentHP}`);
+      });
+    }, "fn")
+  }
+};
+
+// src/props.ts
+var Props = {
+  config: {},
+  ctx: {},
+  userPorpsTemp: {},
+  async init(config, ctx) {
+    Props.config = config;
+    Props.ctx = ctx;
+    ctx.database.extend("smm_gensokyo_user_props", {
+      userId: "string",
+      props: "json"
+    }, {
+      primary: "userId",
+      autoInc: false
     });
-    if (team.isPK) {
-      return `[当前战况]
-攻击方：
-` + selfTemp.join("\n") + "\n\n防御方：\n" + goalTemp.join("\n");
-    }
-    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: "平局", 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: "" };
-  },
-  /** 清理战场 */
-  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];
-      }
+    const temp = {};
+    const propsList = await ctx.database.get("smm_gensokyo_user_props", {});
+    propsList.forEach((item) => {
+      temp[item.userId] = item.props;
     });
+    Props.userPorpsTemp = temp;
   },
-  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) {
-      const buffMsg = settlementBuff(agent);
-      buffMsg && msgList.push(buffMsg);
-      if (agent.hp <= 0) {
-        if (agent.type == "玩家" && !User.userTempData[agent.userId]?.isDie) {
-          User.userTempData[agent.userId].hp = 0;
-          User.userTempData[agent.userId].isDie = true;
-        }
-        continue;
-      }
-      if (!agent.gain.dizziness) {
-        let lifeGoalList = [];
-        let lifeSelfList = [];
-        if (agent.for == "self") {
-          lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
-          lifeSelfList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
-        } else {
-          lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
-          lifeSelfList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
-        }
-        if (!lifeGoalList.length) continue;
-        let selectGoal = {};
-        let isMy = false;
-        let funType = "普攻";
-        if (!agent.gain.chaos) {
-          if (agent.type == "玩家" && agent.userId == session.userId) {
-            isMy = true;
-            funType = atkType;
-            selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-          } else if (agent.type == "玩家") {
-            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-          } else {
-            selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
-            if (random(0, 10) < 4 && agent.fn?.length) {
-              funType = getSkillFn(agent.fn);
-            }
-          }
-        } else {
-          const fliteMyList = allAgentList.filter((item) => item.id !== agent.id && item.hp > 0);
-          if (!fliteMyList.length) continue;
-          selectGoal = fliteMyList[Math.random() * fliteMyList.length];
-        }
-        const noralAtk = /* @__PURE__ */ __name(() => {
-          const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
-          giveDamage(agent, selectGoal, damageInfo);
-          msgList.push(
-            `${getLineupName(agent)} 使用普攻攻击了 ${getLineupName(selectGoal)}，造成了${damageInfo.harm}伤害。` + moreDamageInfo(damageInfo)
-          );
-        }, "noralAtk");
-        if (funType == "普攻") {
-          noralAtk();
-        } else {
-          if (skillFn[funType]) {
-            let _selectGoal = selectGoal;
-            if (["治疗技" /* 治疗技 */, "增益技" /* 增益技 */].includes(skillFn[funType].type)) {
-              _selectGoal = lifeSelfList.find((item) => item.name == select) || agent;
-            }
-            const selectFn = skillFn[funType];
-            if (selectFn.mp == 0 || agent.mp - selectFn.mp >= 0) {
-              agent.mp -= selectFn.mp;
-              let isNext = false;
-              const fnMsg = selectFn.fn(
-                { self: agent, goal: _selectGoal },
-                { selfList: lifeSelfList, goalList: lifeGoalList },
-                (val) => {
-                  switch (val.type) {
-                    case "伤害技" /* 伤害技 */:
-                      val.target.map((goal) => {
-                        giveDamage(agent, goal, val.damage);
-                      });
-                      break;
-                    case "治疗技" /* 治疗技 */:
-                      val.target.map((goal) => {
-                        giveCure(goal, val.value);
-                      });
-                      break;
-                    case "增益技" /* 增益技 */:
-                      isMy && val.err && session.send(val.err);
-                      break;
-                    case "释放失败" /* 释放失败 */:
-                      isMy && val.err && session.send(val.err);
-                    default:
-                      break;
-                  }
-                  isNext = val.isNext;
-                }
-              );
-              fnMsg && msgList.push(fnMsg);
-              isNext && noralAtk();
-            } else {
-              isMy && await session.send(`MP不足，释放失败！`);
-              noralAtk();
-            }
-          } else {
-            isMy && await session.send(`未持有该技能或者该技能不存在，释放失败！`);
-            noralAtk();
-          }
-        }
-      }
-    }
-    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);
+  /** 创建本地数据 */
+  async initUserPropsData(userId) {
+    if (!Props.userPorpsTemp[userId]) {
+      Props.userPorpsTemp[userId] = {};
+      const temp = {
+        userId,
+        props: {}
+      };
+      await Props.ctx.database.create("smm_gensokyo_user_props", temp);
     }
   },
-  /** 结算奖励 */
-  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 > 0 ? agent.hp : 0;
-      User.userTempData[agent.userId].mp = agent.mp;
-      if (User.userTempData[agent.userId].hp <= 0) {
-        User.userTempData[agent.userId].isDie = true;
+  /** 获取持有道具信息 */
+  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 propsData2 = Props.userPorpsTemp[userId];
+    if (propsData2) {
+      const temp = {
+        props: propsData2
+      };
+      await Props.ctx.database.set("smm_gensokyo_user_props", { userId }, temp);
+    }
+  },
+  /** 使用指定道具 */
+  async userProps(session, propsName) {
+    const userId = session.userId;
+    const userPropsData = Props.userPorpsTemp[userId];
+    if (!userPropsData) return;
+    if (!userPropsData[propsName]) {
+      await session.send(`您似乎没有${propsName}这个道具...`);
+      return;
+    }
+    if (propsData[propsName].cooling) {
+      if (!coolingTemp[userId]) coolingTemp[userId] = {};
+      if (!coolingTemp[userId][propsName]) coolingTemp[userId][propsName] = 0;
+      const gapTime = Date.now() - coolingTemp[userId][propsName];
+      if (gapTime < propsData[propsName].cooling) {
+        await session.send(`该道具冷却还未结束，请等待${Math.ceil((coolingTemp[userId][propsName] - gapTime) / 60)}秒！`);
+        return;
+      } else {
+        coolingTemp[userId][propsName] = Date.now();
       }
-    }, "aynchronize");
-    if (tempData.isPK) {
-      if (overInfo.win == "self") {
-        await session.send("攻击方获得20EXP、5货币");
-        for (const agent of allList) {
-          aynchronize(agent);
-          if (agent.for == "self") {
-            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") {
-            await User.giveExp(agent.userId, 20, async (val) => await msg(val));
-            await User.giveMonetary(agent.userId, 5);
-          }
-        }
+    }
+    User.loseProps(userId, { name: propsName, val: 1 }, async (val) => {
+      if (val.err) {
+        await session.send(val.err);
+        return;
       }
-    } else {
-      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)
-              });
-            }
-          });
+      if (propsData[propsName].cooling) {
+        coolingTemp[userId];
+      }
+      const result = await propsData[propsName].fn(session);
+      if (result && typeof result === "object" && "err" in result) {
+        if (result.err) {
+          await User.giveProps(userId, [{ name: propsName, val: 1 }]);
         }
-      });
-      if (overInfo.win == "self") {
-        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] = 0;
-              propsDict[item.name]++;
-            });
-            const msg2 = Object.keys(propsDict).map((item) => {
-              return `${item} ${propsDict[item]}个`;
-            }).join("\n");
-            await session.send(`${agent.name}在战斗中获得：` + msg2);
-          });
+    });
+  }
+};
+var coolingTemp = {};
+
+// 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
+    }
+  },
+  ["法师" /* 法师 */]: {
+    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
+    }
+  }
+};
+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",
+        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;
+  },
+  /** 获取玩家名字 */
+  getUserName(userId) {
+    return User.userTempData[userId].playName || null;
+  },
+  /** 获取角色基础属性 */
+  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,
+      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 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;
     }
-  }
-};
-function getLineupName(agent) {
-  return `[${agent.type}]${agent.name}`;
-}
-__name(getLineupName, "getLineupName");
-function getSkillFn(fnList) {
-  const totalProb = fnList.reduce((sum, item) => sum + item.prob, 0);
-  const random2 = Math.random() * totalProb;
-  let currentProb = 0;
-  for (const item of fnList) {
-    currentProb += item.prob;
-    if (random2 < currentProb) {
-      return item.name;
+    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 (Object.keys(monsterData).includes(playname?.trim())) {
+      await session.send("请不要设置怪物的名字！");
+      return;
+    }
+    if (playname.trim().length > 6 || playname.trim().length < 1) {
+      await session.send("名字长度有问题，要求小于 6个字，大于 1个字");
+      return;
+    }
+    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);
     }
-  }
-  return fnList[fnList.length - 1].name;
-}
-__name(getSkillFn, "getSkillFn");
-function initBattleAttribute(data) {
-  if ("playName" in data) {
-    const userData = data;
     const temp = {
-      id: Date.now(),
-      userId: userData.userId,
-      name: userData.playName,
-      lv: userData.lv,
-      type: "玩家",
-      selfType: userData.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,
-        chaos: false,
-        dizziness: false,
-        reduction: 0
-      },
-      buff: {},
-      fn: [],
-      expand: {}
+      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
     };
-    return temp;
-  } else {
-    const monsterData2 = data;
+    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 = {
-      id: Date.now(),
-      name: monsterData2.name,
-      type: "怪物",
-      selfType: monsterData2.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,
-        chaos: false,
-        dizziness: false,
-        reduction: 0
-      },
-      buff: {},
-      fn: monsterData2.fn ? JSON.parse(JSON.stringify(monsterData2.fn)) : [],
-      expand: {}
+      playName: userInfo.playName.trim(),
+      hp: userInfo.hp,
+      pp: userInfo.pp,
+      mp: userInfo.mp,
+      lv: userInfo.lv,
+      exp: userInfo.exp
     };
-    return temp;
-  }
-}
-__name(initBattleAttribute, "initBattleAttribute");
-
-// src/data/initProps.ts
-var propsData = {
-  "红药": {
-    name: "红药",
-    type: "消耗类" /* 消耗类 */,
-    info: "回复自身20HP",
-    price: 10,
-    fn: /* @__PURE__ */ __name(async 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")
+    User.ctx.database.set("smm_gensokyo_user_attribute", { userId }, temp);
+  },
+  /** 给予玩家经验 */
+  async giveExp(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    const beforData = { ...User.getUserAttributeByUserId(userId) };
+    let isUp = false;
+    userInfo.exp += value;
+    while (true) {
+      const { maxExp } = User.getUserAttributeByUserId(userId);
+      if (userInfo.exp < maxExp) break;
+      userInfo.lv += 1;
+      userInfo.exp -= maxExp;
+      isUp = true;
+    }
+    if (isUp) {
+      const afterData = User.getUserAttributeByUserId(userId);
+      const upTemp = {
+        name: afterData.playName,
+        lv: afterData.lv,
+        maxHp: afterData.maxHp - beforData.maxHp,
+        maxMp: afterData.maxMp = beforData.maxMp,
+        atk: afterData.atk - beforData.atk,
+        def: afterData.def - beforData.def
+      };
+      fn && await fn(upTemp);
+    }
+    await User.setDatabaseUserAttribute(userId);
+  },
+  /** 给予玩家死亡 */
+  async giveDie(userId) {
+    const userInfo = User.userTempData[userId];
+    userInfo.hp = 0;
+    userInfo.isDie = true;
+    await User.setDatabaseUserAttribute(userId);
   },
-  "蓝药": {
-    name: "蓝药",
-    type: "消耗类" /* 消耗类 */,
-    info: "回复自身20MP",
-    price: 10,
-    fn: /* @__PURE__ */ __name(async 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")
+  /** 给予玩家复活 */
+  async giveLife(userId, val, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!val) {
+      const { maxHp } = User.getUserAttributeByUserId(userId);
+      userInfo.hp = maxHp;
+    } else {
+      userInfo.hp = val;
+    }
+    await User.setDatabaseUserAttribute(userId);
+    fn && await fn({ currentHP: userInfo.hp });
   },
-  "初级万能药": {
-    name: "初级万能药",
-    type: "消耗类" /* 消耗类 */,
-    info: "回复自身20MP和20HP",
-    price: 20,
-    fn: /* @__PURE__ */ __name(async 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);
+  /** 给予玩家血量或者蓝量 */
+  async giveHPMP(userId, value, fn) {
+    const userInfo = User.userTempData[userId];
+    if (!userInfo) return;
+    if (userInfo.isDie) {
+      fn && await fn({
+        currentHP: 0,
+        currentMP: 0,
+        err: "角色已死亡，无法使用恢复道具。"
       });
-    }, "fn")
-  },
-  "初级复活卷轴": {
-    name: "初级复活卷轴",
-    type: "消耗类" /* 消耗类 */,
-    info: "复活玩家，复活时保留 20% 血量。(该道具使用完需要冷却 6 分钟)",
-    price: 10,
-    cooling: 3600,
-    fn: /* @__PURE__ */ __name(async function(session) {
-      if (BattleData.isBattleByUserId(session.userId)) {
-        session.send(`该道具在战斗中无法使用！请在小队脱离战斗后使用。`);
-        return { err: true };
+      return;
+    }
+    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 {
+        agent.hp = agent.maxHp;
       }
-      if (!User.isDie(session.userId)) {
-        session.send(`您还没有阵亡，使用失败！`);
-        return { err: true };
+      if (agent.mp + (value.mp || 0) < agent.maxMp) {
+        agent.mp += value.mp || 0;
+      } else {
+        agent.mp = agent.maxMp;
       }
-      const { maxHp } = User.getUserAttributeByUserId(session.userId);
-      User.giveLife(session.userId, Math.floor(maxHp * 0.2), async (val) => {
-        await session.send(`复活成功，当前血量：${val.currentHP}`);
+      fn && await fn({
+        currentHP: agent.hp,
+        currentMP: agent.mp
       });
-    }, "fn")
-  }
-};
-
-// src/props.ts
-var Props = {
-  config: {},
-  ctx: {},
-  userPorpsTemp: {},
-  async init(config, ctx) {
-    Props.config = config;
-    Props.ctx = ctx;
-    ctx.database.extend("smm_gensokyo_user_props", {
-      userId: "string",
-      props: "json"
-    }, {
-      primary: "userId",
-      autoInc: false
-    });
-    const temp = {};
-    const propsList = await ctx.database.get("smm_gensokyo_user_props", {});
-    propsList.forEach((item) => {
-      temp[item.userId] = item.props;
-    });
-    Props.userPorpsTemp = temp;
-  },
-  /** 创建本地数据 */
-  async initUserPropsData(userId) {
-    if (!Props.userPorpsTemp[userId]) {
-      Props.userPorpsTemp[userId] = {};
-      const temp = {
-        userId,
-        props: {}
-      };
-      await Props.ctx.database.create("smm_gensokyo_user_props", temp);
+      return;
     }
-  },
-  /** 获取持有道具信息 */
-  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}个`;
+    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
     });
-    return msgList.length ? `当前您持有如下道具：
-
-` + msgList.join("\n") : "您没有任何道具...";
+    await User.setDatabaseUserAttribute(userId);
   },
-  /** 更新本地数据库对应数据 */
-  async setDatabasePropsData(userId) {
-    const propsData2 = Props.userPorpsTemp[userId];
-    if (propsData2) {
-      const temp = {
-        props: propsData2
-      };
-      await Props.ctx.database.set("smm_gensokyo_user_props", { userId }, temp);
+  /** 给予玩家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 {
+      userInfo.pp = maxPp;
     }
+    fn && await fn({
+      currentPP: userInfo.pp
+    });
+    await User.setDatabaseUserAttribute(userId);
   },
-  /** 使用指定道具 */
-  async userProps(session, propsName) {
-    const userId = session.userId;
-    const userPropsData = Props.userPorpsTemp[userId];
-    if (!userPropsData) return;
-    if (!userPropsData[propsName]) {
-      await session.send(`您似乎没有${propsName}这个道具...`);
+  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值不够，消耗失败！"
+      });
       return;
     }
-    if (propsData[propsName].cooling) {
-      if (!coolingTemp[userId]) coolingTemp[userId] = {};
-      if (!coolingTemp[userId][propsName]) coolingTemp[userId][propsName] = 0;
-      const gapTime = Date.now() - coolingTemp[userId][propsName];
-      if (gapTime < propsData[propsName].cooling) {
-        await session.send(`该道具冷却还未结束，请等待${Math.ceil((coolingTemp[userId][propsName] - gapTime) / 60)}秒！`);
-        return;
-      } else {
-        coolingTemp[userId][propsName] = Date.now();
-      }
+    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 });
     }
-    User.loseProps(userId, { name: propsName, val: 1 }, async (val) => {
-      if (val.err) {
-        await session.send(val.err);
-        return;
-      }
-      if (propsData[propsName].cooling) {
-        coolingTemp[userId];
-      }
-      const result = await propsData[propsName].fn(session);
-      if (result && typeof result === "object" && "err" in result) {
-        if (result.err) {
-          await User.giveProps(userId, [{ name: propsName, val: 1 }]);
-        }
+  },
+  /** 收取玩家货币 */
+  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;
       }
-    });
-  }
-};
-var coolingTemp = {};
-
-// 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
+      await User.ctx.monetary.cost(bindData.aid, val);
+      fn && await fn({
+        val: Math.abs(val),
+        currentVal: currentM.value - val
+      });
     }
   },
-  ["法师" /* 法师 */]: {
-    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
+  /** 给予玩家指定道具 */
+  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 (!propsData[item.name]) continue;
+      if (!userProps[item.name]) {
+        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 });
     }
+    await Props.setDatabasePropsData(userId);
+    fn && await fn({
+      currentProps: upProps
+    });
   },
-  ["刺客" /* 刺客 */]: {
-    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
+  /** 去除玩家指定道具 */
+  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];
+    await Props.setDatabasePropsData(userId);
+    fn && await fn({
+      currentProps: { name: props.name, val: userProps[props.name]?.value || 0 }
+    });
+  },
+  /** 目标是否死亡 */
+  isDie(userId) {
+    return User.userTempData[userId]?.isDie;
   }
 };
-var User = {
+
+// src/map.ts
+var delay = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "delay");
+var GensokyoMap = {
   config: {},
   ctx: {},
-  userTempData: {},
+  mapLocalData: {},
+  userCurrentLoal: {},
   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;
+    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
     });
-    User.userTempData = temp;
-  },
-  /** 获取玩家名字 */
-  getUserName(userId) {
-    return User.userTempData[userId].playName || null;
-  },
-  /** 获取角色基础属性 */
-  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,
-      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));
+    GensokyoMap.mapLocalData = {
+      1: {
+        "地下墓穴": {
+          floor: 1,
+          areaName: "地下墓穴",
+          type: "BOSS区" /* BOSS区 */,
+          needLv: 10,
+          down: "蜘蛛洞穴",
+          monster: [{ name: "古明地觉", lv: 15 }]
+        },
+        "蜘蛛洞穴": {
+          floor: 1,
+          areaName: "蜘蛛洞穴",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "地下墓穴",
+          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: "蜘蛛森林一",
+          monster: [{ name: "大妖精", lv: 3 }]
+        },
+        "蜘蛛森林通道": {
+          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: "冒险区" /* 冒险区 */,
+          monster: [{ name: "dora", lv: 2 }, { name: "dora", lv: 2 }, { name: "dora", lv: 3 }, { name: "dora", lv: 2 }],
+          needLv: 1,
+          right: "绿野平原一",
+          down: "绿野平原五"
+        },
+        "绿野平原三": {
+          floor: 1,
+          areaName: "绿野平原三",
+          type: "冒险区" /* 冒险区 */,
+          monster: [{ name: "dora", lv: 5 }],
+          needLv: 1,
+          left: "绿野平原一",
+          down: "绿野平原六"
+        },
+        "绿野平原四": {
+          floor: 1,
+          areaName: "绿野平原四",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "绿野平原一",
+          down: "野猪巢穴",
+          left: "绿野平原五",
+          right: "绿野平原六",
+          monster: [{ name: "琪露诺", lv: 10 }]
+        },
+        "绿野平原五": {
+          floor: 1,
+          areaName: "绿野平原五",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          top: "绿野平原二",
+          right: "绿野平原四"
+        },
+        "绿野平原六": {
+          floor: 1,
+          areaName: "绿野平原六",
+          type: "冒险区" /* 冒险区 */,
+          needLv: 1,
+          left: "绿野平原四",
+          top: "绿野平原三",
+          monster: [{ name: "绿毒蛇", lv: 12 }]
+        },
+        "野猪巢穴": {
+          floor: 1,
+          areaName: "野猪巢穴",
+          type: "BOSS区" /* BOSS区 */,
+          needLv: 15,
+          top: "绿野平原四",
+          monster: [{ name: "蓬莱山辉夜", lv: 20 }]
         }
-      }
-    });
-    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 (Object.keys(monsterData).includes(playname?.trim())) {
-      await session.send("请不要设置怪物的名字！");
-      return;
-    }
-    if (playname.trim().length < 6 || playname.trim().length > 1) {
-      await session.send("名字长度有问题，要求小于 6个字，大于 1个字");
-      return;
-    }
-    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
+      },
+      2: {
+        "传送门": {
+          floor: 2,
+          areaName: "传送门",
+          type: "传送门" /* 传送门 */,
+          needLv: 1,
+          right: "希望之泉"
+        },
+        "希望之泉": {
+          floor: 2,
+          areaName: "希望之泉",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "爱之湖",
+          down: "农田",
+          left: "传送门",
+          right: "2层-商店"
+        },
+        "爱之湖": {
+          floor: 2,
+          areaName: "爱之湖",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          down: "希望之泉",
+          right: "旅馆"
+        },
+        "农田": {
+          floor: 2,
+          areaName: "农田",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "希望之泉",
+          right: "银行"
+        },
+        "银行": {
+          floor: 2,
+          areaName: "银行",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          top: "2层-商店",
+          left: "农田"
+        },
+        "旅馆": {
+          floor: 2,
+          areaName: "旅馆",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          down: "2层-商店",
+          left: "爱之湖"
+        },
+        "2层-商店": {
+          floor: 2,
+          areaName: "2层-商店",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          right: "大草场"
+        },
+        "大草场": {
+          floor: 2,
+          areaName: "大草场",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          left: "2层-商店",
+          right: "森林岔口"
+        },
+        "森林岔口": {
+          floor: 2,
+          areaName: "森林岔口",
+          type: "安全区" /* 安全区 */,
+          needLv: 1,
+          left: "大草场"
+        }
+      }
     };
-    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));
+    console.log(JSON.stringify(GensokyoMap.mapLocalData));
+    const userPoistionList = await ctx.database.get("smm_gensokyo_map_position", {});
+    const poistionTemp = {};
+    userPoistionList.forEach((poistion) => {
+      poistion.moveing = false;
+      poistionTemp[poistion.userId] = poistion;
+    });
+    GensokyoMap.userCurrentLoal = poistionTemp;
   },
-  /** 信息格式化 */
-  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}` : "");
+  /** 获取层的数据 */
+  getBaseFloorLocal(floor) {
+    return GensokyoMap.mapLocalData[floor] || null;
   },
-  /** 写入用户数据到数据库 */
-  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);
+  /** 获取用户当前区域信息 */
+  getUserCurrentArea(userid) {
+    const { floor, areaName } = GensokyoMap.userCurrentLoal[userid] || {};
+    if (!(floor && areaName)) return null;
+    return GensokyoMap.mapLocalData[floor][areaName] || null;
   },
-  /** 给予玩家经验 */
-  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
+  /** 初始化用户位置 */
+  initUserPoistion(session, userData) {
+    if (!GensokyoMap.userCurrentLoal[session.userId]) {
+      GensokyoMap.userCurrentLoal[session.userId] = {
+        userId: session.userId,
+        floor: 1,
+        areaName: "传送门",
+        moveing: false,
+        playName: userData.playName
       };
-      fn && await fn(upTemp);
     }
-    await User.setDatabaseUserAttribute(userId);
-  },
-  /** 给予玩家死亡 */
-  async giveDie(userId) {
-    const userInfo = User.userTempData[userId];
-    userInfo.hp = 0;
-    userInfo.isDie = true;
-    await User.setDatabaseUserAttribute(userId);
+    GensokyoMap.setLocalStoragePoistionData(session.userId);
   },
-  /** 给予玩家复活 */
-  async giveLife(userId, val, fn) {
-    const userInfo = User.userTempData[userId];
-    if (!val) {
-      const { maxHp } = User.getUserAttributeByUserId(userId);
-      userInfo.hp = maxHp;
-    } else {
-      userInfo.hp = val;
+  /** 位置信息存储到数据库 */
+  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);
     }
-    await User.setDatabaseUserAttribute(userId);
-    fn && await fn({ currentHP: userInfo.hp });
   },
-  /** 给予玩家血量或者蓝量 */
-  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;
-    }
-    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 {
-        agent.hp = agent.maxHp;
+  /** 用户移动 */
+  async move(session, type, fn) {
+    try {
+      const userCurrentArea = GensokyoMap.userCurrentLoal[session.userId] || {};
+      const { floor, areaName, moveing } = userCurrentArea;
+      if (moveing) {
+        await session.send("当前移动冷却中，请稍等...");
+        return;
       }
-      if (agent.mp + (value.mp || 0) < agent.maxMp) {
-        agent.mp += value.mp || 0;
-      } else {
-        agent.mp = agent.maxMp;
+      if (!(floor && areaName)) {
+        await session.send("您当前位置有误，请使用(还没写好的指令)脱离卡死...");
+        return;
       }
-      fn && await fn({
-        currentHP: agent.hp,
-        currentMP: agent.mp
-      });
-      return;
-    }
-    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: "当前状态全满，无需回复。"
-      });
+      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 > User.userTempData[session.userId].lv) {
+        await session.send(`当前区域由于您的等级未达到最低要求，暂时无法进入。
+需要等级：${newArea.needLv}级`);
+        userCurrentArea.moveing = false;
+        return;
+      }
+      if (BattleData.isTeam(session)) {
+        const { userId } = session;
+        const myTeamList = [];
+        Object.keys(BattleData.teamTemp).forEach((_userId) => {
+          if (BattleData.teamTemp[userId].for == userId && userId !== _userId) {
+            myTeamList.push(_userId);
+          }
+        });
+        const belowUser = myTeamList.filter((teamUserId) => newArea.needLv > User.userTempData[teamUserId].lv);
+        if (belowUser.length) {
+          await session.send(
+            `移动失败！队伍存在限制进入等级(lv.${newArea.needLv})玩家，
+目前限制进入的玩家：
+${belowUser.map((item) => {
+              return `Lv.${User.userTempData[item].lv} ${User.userTempData[item].playName}`;
+            }).join("\n")}`
+          );
+          userCurrentArea.moveing = false;
+          return;
+        }
+        for (const moveTeamUserId of myTeamList) {
+          GensokyoMap.userCurrentLoal[moveTeamUserId].areaName = newArea.areaName;
+          GensokyoMap.userCurrentLoal[moveTeamUserId].floor = newArea.floor;
+          GensokyoMap.userCurrentLoal[moveTeamUserId].moveing = false;
+          await GensokyoMap.setLocalStoragePoistionData(moveTeamUserId);
+        }
+      }
+      userCurrentArea.areaName = newArea.areaName;
+      const areaInfo = {
+        user: { ...userCurrentArea },
+        map: { ...newArea }
+      };
+      fn && await fn(areaInfo);
+      await delay(3e3);
+      userCurrentArea.moveing = false;
+      GensokyoMap.setLocalStoragePoistionData(session.userId);
       return;
+    } catch (error) {
+      console.log(error);
+      if (GensokyoMap.userCurrentLoal?.[session.userId]) {
+        GensokyoMap.userCurrentLoal[session.userId].moveing = false;
+      }
     }
-    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);
   },
-  /** 给予玩家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 {
-      userInfo.pp = maxPp;
-    }
-    fn && await fn({
-      currentPP: userInfo.pp
+  /** 查询附近玩家 */
+  nearbyPlayersByUserId(userId) {
+    const areaData = GensokyoMap.getUserCurrentArea(userId);
+    const liveUser = [];
+    Object.keys(GensokyoMap.userCurrentLoal).forEach((_userId) => {
+      const userItem = GensokyoMap.userCurrentLoal[_userId];
+      if (userItem.areaName == areaData.areaName && userItem.floor == areaData.floor) {
+        if (userId !== userItem.userId) {
+          liveUser.push({ userId: userItem.userId, playName: userItem.playName });
+        }
+      }
     });
-    await User.setDatabaseUserAttribute(userId);
+    return liveUser;
   },
-  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值不够，消耗失败！"
-      });
-      return;
-    }
-    userInfo.pp -= value;
-    fn && await fn({
-      currentPP: userInfo.pp
+  /** 区域信息格式化 */
+  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);
+        }
+      }
     });
-    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 });
+    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/mapHtml.ts
+function generateMapHTML(mapData, currentAreaName) {
+  const centerKey = Object.keys(mapData).find((key) => mapData[key].type === "传送门");
+  if (!centerKey) {
+    return "<div>未找到传送门区域</div>";
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const grid = {};
+  let minRow = 0, maxRow = 0, minCol = 0, maxCol = 0;
+  function placeArea(key, row, col) {
+    if (visited.has(key)) return;
+    visited.add(key);
+    const area = mapData[key];
+    if (!area) return;
+    const connections = {
+      top: false,
+      left: false,
+      right: false,
+      down: false
+    };
+    if (!grid[row]) grid[row] = {};
+    grid[row][col] = { area, key, row, col, connections };
+    minRow = Math.min(minRow, row);
+    maxRow = Math.max(maxRow, row);
+    minCol = Math.min(minCol, col);
+    maxCol = Math.max(maxCol, col);
+    if (area.top) {
+      placeArea(area.top, row - 1, col);
+      connections.top = true;
+      if (grid[row - 1]?.[col]) {
+        grid[row - 1][col].connections.down = true;
+      }
     }
-  },
-  /** 收取玩家货币 */
-  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;
+    if (area.left) {
+      placeArea(area.left, row, col - 1);
+      connections.left = true;
+      if (grid[row]?.[col - 1]) {
+        grid[row][col - 1].connections.right = true;
       }
-      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 (!propsData[item.name]) continue;
-      if (!userProps[item.name]) {
-        userProps[item.name] = {
-          name: propsItem.name,
-          type: propsItem.type,
-          value: 0
-        };
+    if (area.right) {
+      placeArea(area.right, row, col + 1);
+      connections.right = true;
+      if (grid[row]?.[col + 1]) {
+        grid[row][col + 1].connections.left = true;
       }
-      userProps[item.name].value += item.val || 1;
-      upProps.push({ name: item.name, val: userProps[item.name].value });
     }
-    await Props.setDatabasePropsData(userId);
-    fn && await fn({
-      currentProps: upProps
-    });
-  },
-  /** 去除玩家指定道具 */
-  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 (area.down) {
+      placeArea(area.down, row + 1, col);
+      connections.down = true;
+      if (grid[row + 1]?.[col]) {
+        grid[row + 1][col].connections.top = true;
+      }
     }
-    if (!userProps[props.name]) {
-      userProps[props.name] = {
-        name: propsItem.name,
-        type: propsItem.type,
-        value: 0
-      };
+  }
+  __name(placeArea, "placeArea");
+  placeArea(centerKey, 0, 0);
+  const cellWidth = 160;
+  const cellHeight = 120;
+  const svgWidth = (maxCol - minCol + 1) * cellWidth;
+  const svgHeight = (maxRow - minRow + 1) * cellHeight;
+  let html = `
+<style>
+.map-container {
+    display: inline-block;
+    position: relative;
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    font-size: 12px;
+    background-color: transparent;
+    padding: 20px;
+    border-radius: 12px;
+    min-width: 100vw;
+    box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+}
+.map-table {
+    border-collapse: separate;
+    border-spacing: 0;
+    position: relative;
+    z-index: 2;
+}
+.map-cell {
+    width: ${cellWidth}px;
+    height: ${cellHeight}px;
+    border: none;
+    padding: 12px;
+    vertical-align: top;
+    text-align: center;
+    background: rgba(255, 255, 255, 0.95);
+    border-radius: 8px;
+    transition: all 0.3s ease;
+    position: relative;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    backdrop-filter: blur(10px);
+}
+.map-cell:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15);
+}
+.empty-cell {
+    background: transparent !important;
+    box-shadow: none !important;
+    border: none !important;
+}
+.area-name {
+    font-weight: 700;
+    margin-bottom: 6px;
+    color: #2d3748;
+    font-size: 14px;
+    letter-spacing: 0.5px;
+}
+.area-type {
+    font-size: 11px;
+    color: #718096;
+    margin-bottom: 6px;
+    padding: 2px 8px;
+    background: rgba(237, 242, 247, 0.8);
+    border-radius: 12px;
+    display: inline-block;
+}
+.area-info {
+    font-size: 10px;
+    color: #4a5568;
+    margin-bottom: 6px;
+    font-style: italic;
+}
+.monster-list, .npc-list {
+    font-size: 10px;
+    color: #2d3748;
+    text-align: left;
+    margin-top: 6px;
+    padding-left: 8px;
+}
+.monster-list {
+    border-left: 2px solid #e53e3e;
+}
+.npc-list {
+    border-left: 2px solid #38a169;
+}
+.safe { 
+    background: linear-gradient(135deg, rgba(224, 247, 250, 0.95), rgba(129, 230, 217, 0.95));
+    border: 2px solid #38b2ac;
+}
+.boss { 
+    background: linear-gradient(135deg, rgba(255, 235, 238, 0.95), rgba(254, 178, 178, 0.95));
+    border: 2px solid #e53e3e;
+}
+.adventure { 
+    background: linear-gradient(135deg, rgba(241, 248, 233, 0.95), rgba(154, 230, 180, 0.95));
+    border: 2px solid #38a169;
+}
+.portal { 
+    background: linear-gradient(135deg, rgba(255, 243, 224, 0.95), rgba(251, 211, 141, 0.95));
+    border: 2px solid #ed8936;
+}
+.current {
+    background: linear-gradient(135deg, rgba(255, 249, 196, 0.95), rgba(254, 240, 138, 0.95)) !important;
+    border: 3px solid #d69e2e !important;
+    box-shadow: 0 0 20px rgba(214, 158, 46, 0.4), 0 8px 16px rgba(0, 0, 0, 0.2);
+    transform: scale(1.08);
+    z-index: 10;
+    animation: glow 2s ease-in-out infinite alternate;
+}
+@keyframes glow {
+    from {
+        box-shadow: 0 0 20px rgba(214, 158, 46, 0.4), 0 8px 16px rgba(0, 0, 0, 0.2);
     }
-    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;
+    to {
+        box-shadow: 0 0 30px rgba(214, 158, 46, 0.6), 0 10px 20px rgba(0, 0, 0, 0.3);
+    }
+}
+.current .area-name {
+    color: #744210;
+    font-weight: 900;
+    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+.current-marker {
+    display: inline-block;
+    width: 10px;
+    height: 10px;
+    background: linear-gradient(135deg, #d69e2e, #744210);
+    border-radius: 50%;
+    margin-right: 6px;
+    animation: pulse 1.5s ease-in-out infinite;
+    box-shadow: 0 0 8px rgba(214, 158, 46, 0.8);
+}
+@keyframes pulse {
+    0% { transform: scale(1); opacity: 1; }
+    50% { transform: scale(1.4); opacity: 0.8; }
+    100% { transform: scale(1); opacity: 1; }
+}
+.connection-lines {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: 1;
+    pointer-events: none;
+}
+.connection-line {
+    stroke: rgba(255, 255, 255, 0.7);
+    stroke-width: 3;
+    stroke-linecap: round;
+    filter: drop-shadow(0 2px 4px rgba(0, 0, 0, 0.2));
+}
+.connection-line-dotted {
+    stroke-dasharray: 5, 5;
+}
+.connection-line-solid {
+    stroke-dasharray: none;
+}
+.connection-dot {
+    fill: rgba(255, 255, 255, 0.9);
+    stroke: #4a5568;
+    stroke-width: 1;
+    filter: drop-shadow(0 2px 3px rgba(0, 0, 0, 0.2));
+}
+</style>
+<div class="map-container">
+<svg class="connection-lines" width="${svgWidth}" height="${svgHeight}">
+`;
+  for (let r = minRow; r <= maxRow; r++) {
+    for (let c = minCol; c <= maxCol; c++) {
+      const cell = grid[r]?.[c];
+      if (cell) {
+        const { connections } = cell;
+        const x = (c - minCol) * cellWidth + cellWidth / 2;
+        const y = (r - minRow) * cellHeight + cellHeight / 2;
+        html += `<circle class="connection-dot" cx="${x}" cy="${y}" r="4" />`;
+        if (connections.top) {
+          const targetX = x;
+          const targetY = y - cellHeight;
+          html += `<line class="connection-line connection-line-dotted" 
+                        x1="${x}" y1="${y}" 
+                        x2="${targetX}" y2="${targetY}" />`;
+        }
+        if (connections.down) {
+          const targetX = x;
+          const targetY = y + cellHeight;
+          html += `<line class="connection-line connection-line-dotted" 
+                        x1="${x}" y1="${y}" 
+                        x2="${targetX}" y2="${targetY}" />`;
+        }
+        if (connections.left) {
+          const targetX = x - cellWidth;
+          const targetY = y;
+          html += `<line class="connection-line connection-line-dotted" 
+                        x1="${x}" y1="${y}" 
+                        x2="${targetX}" y2="${targetY}" />`;
+        }
+        if (connections.right) {
+          const targetX = x + cellWidth;
+          const targetY = y;
+          html += `<line class="connection-line connection-line-dotted" 
+                        x1="${x}" y1="${y}" 
+                        x2="${targetX}" y2="${targetY}" />`;
+        }
+      }
     }
-    userProps[props.name].value -= props.val || 1;
-    if (userProps[props.name].value == 0) delete userProps[props.name];
-    await Props.setDatabasePropsData(userId);
-    fn && await fn({
-      currentProps: { name: props.name, val: userProps[props.name]?.value || 0 }
-    });
-  },
-  /** 目标是否死亡 */
-  isDie(userId) {
-    return User.userTempData[userId]?.isDie;
   }
-};
+  html += `</svg><table class="map-table">`;
+  for (let r = minRow; r <= maxRow; r++) {
+    html += "<tr>";
+    for (let c = minCol; c <= maxCol; c++) {
+      const cell = grid[r]?.[c];
+      if (cell) {
+        const { area, key } = cell;
+        const isCurrent = currentAreaName === area.areaName;
+        const typeClass = area.type === "安全区" ? "safe" : area.type === "BOSS区" ? "boss" : area.type === "冒险区" ? "adventure" : area.type === "传送门" ? "portal" : "";
+        const currentClass = isCurrent ? "current" : "";
+        html += `<td class="map-cell ${typeClass} ${currentClass}">`;
+        html += `<div class="area-name">`;
+        if (isCurrent) {
+          html += `<span class="current-marker"></span>`;
+        }
+        html += `${area.areaName}`;
+        if (isCurrent) {
+          html += ` <span style="color:#744210;font-size:11px;font-weight:600;">(当前位置)</span>`;
+        }
+        html += `</div>`;
+        html += `<div class="area-type">${area.type} (Lv.${area.needLv}+)</div>`;
+        if (area.info) {
+          html += `<div class="area-info">${area.info}</div>`;
+        }
+        if (area.npc && area.npc.length > 0) {
+          html += `<div class="npc-list">NPC: ${area.npc.join(", ")}</div>`;
+        }
+        if (area.monster && area.monster.length > 0) {
+          html += `<div class="monster-list">`;
+          area.monster.forEach((m) => {
+            html += `<div style="margin: 2px 0;">${m.name} <span style="color:#e53e3e">Lv.${m.lv}</span></div>`;
+          });
+          html += `</div>`;
+        }
+        html += `</td>`;
+      } else {
+        html += `<td class="map-cell empty-cell"></td>`;
+      }
+    }
+    html += "</tr>";
+  }
+  html += `
+</table>
+</div>
+`;
+  return html;
+}
+__name(generateMapHTML, "generateMapHTML");
 
 // src/index.ts
 var name = "smmcat-gensokyo";
 var inject = {
-  required: ["monetary", "database"]
+  required: ["monetary", "database", "puppeteer"]
 };
 var Config = import_koishi2.Schema.object({});
 function apply(ctx, config) {
@@ -2709,17 +3045,6 @@ function apply(ctx, config) {
       return `你已经阵亡，请发送 /补给 进行治疗。`;
     }
     GensokyoMap.move(session, "top" /* 上 */, async (val) => {
-      if (BattleData.isTeam(session)) {
-        const { userId } = session;
-        Object.keys(BattleData.teamTemp).forEach((_userId) => {
-          if (BattleData.teamTemp[userId].for == userId && userId !== _userId) {
-            GensokyoMap.userCurrentLoal[_userId].areaName = GensokyoMap.userCurrentLoal[userId].areaName;
-            GensokyoMap.userCurrentLoal[_userId].floor = GensokyoMap.userCurrentLoal[userId].floor;
-            GensokyoMap.userCurrentLoal[_userId].moveing = false;
-            GensokyoMap.setLocalStoragePoistionData(_userId);
-          }
-        });
-      }
       await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
       if (val.map.type == "冒险区" /* 冒险区 */ && val.map.monster?.length) {
         if (random(0, 10) <= 2) {
@@ -2746,17 +3071,6 @@ function apply(ctx, config) {
       return `你已经阵亡，请发送 /补给 进行治疗。`;
     }
     GensokyoMap.move(session, "down" /* 下 */, async (val) => {
-      if (BattleData.isTeam(session)) {
-        const { userId } = session;
-        Object.keys(BattleData.teamTemp).forEach((_userId) => {
-          if (BattleData.teamTemp[userId].for == userId && userId !== _userId) {
-            GensokyoMap.userCurrentLoal[_userId].areaName = GensokyoMap.userCurrentLoal[userId].areaName;
-            GensokyoMap.userCurrentLoal[_userId].floor = GensokyoMap.userCurrentLoal[userId].floor;
-            GensokyoMap.userCurrentLoal[_userId].moveing = false;
-            GensokyoMap.setLocalStoragePoistionData(_userId);
-          }
-        });
-      }
       await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
       if (val.map.type == "冒险区" /* 冒险区 */ && val.map.monster?.length) {
         if (random(0, 10) <= 2) {
@@ -2783,17 +3097,6 @@ function apply(ctx, config) {
       return `你已经阵亡，请发送 /补给 进行治疗。`;
     }
     GensokyoMap.move(session, "left" /* 左 */, async (val) => {
-      if (BattleData.isTeam(session)) {
-        const { userId } = session;
-        Object.keys(BattleData.teamTemp).forEach((_userId) => {
-          if (BattleData.teamTemp[userId].for == userId && userId !== _userId) {
-            GensokyoMap.userCurrentLoal[_userId].areaName = GensokyoMap.userCurrentLoal[userId].areaName;
-            GensokyoMap.userCurrentLoal[_userId].floor = GensokyoMap.userCurrentLoal[userId].floor;
-            GensokyoMap.userCurrentLoal[_userId].moveing = false;
-            GensokyoMap.setLocalStoragePoistionData(_userId);
-          }
-        });
-      }
       await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
       if (val.map.type == "冒险区" /* 冒险区 */ && val.map.monster?.length) {
         if (random(0, 10) <= 2) {
@@ -2820,17 +3123,6 @@ function apply(ctx, config) {
       return `你已经阵亡，请发送 /补给 进行治疗。`;
     }
     GensokyoMap.move(session, "right" /* 右 */, async (val) => {
-      if (BattleData.isTeam(session)) {
-        const { userId } = session;
-        Object.keys(BattleData.teamTemp).forEach((_userId) => {
-          if (BattleData.teamTemp[userId].for == userId && userId !== _userId) {
-            GensokyoMap.userCurrentLoal[_userId].areaName = GensokyoMap.userCurrentLoal[userId].areaName;
-            GensokyoMap.userCurrentLoal[_userId].floor = GensokyoMap.userCurrentLoal[userId].floor;
-            GensokyoMap.userCurrentLoal[_userId].moveing = false;
-            GensokyoMap.setLocalStoragePoistionData(_userId);
-          }
-        });
-      }
       await session.send(GensokyoMap.userAreaTextFormat(userData.playName, val));
       if (val.map.type == "冒险区" /* 冒险区 */ && val.map.monster?.length) {
         if (random(0, 10) <= 2) {
@@ -2962,12 +3254,16 @@ function apply(ctx, config) {
     const userData = await User.getUserAttribute(session);
     if (!userData) return;
     GensokyoMap.initUserPoistion(session, userData);
+    if (BattleData.isBattle(session)) {
+      await session.send("当前正在战斗，请结束后再使用改");
+      return;
+    }
     if (temp[session.userId] == void 0) {
       temp[session.userId] = 0;
     }
     const useTime = Date.now() - temp[session.userId];
     if (useTime < 36e4) {
-      return `请等待下一个补给时间！剩余${Math.floor(36e4 - useTime / 6e4)}分钟。`;
+      return `请等待下一个补给时间！剩余${Math.floor((36e4 - useTime) / 6e4)}分钟。`;
     }
     temp[session.userId] = Date.now();
     const { maxHp, maxMp, playName } = User.getUserAttributeByUserId(session.userId);
@@ -2981,18 +3277,27 @@ function apply(ctx, config) {
   });
   ctx.command("幻想乡/队伍操作");
   ctx.command("队伍操作/队伍创建").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     if (BattleData.isBattle(session)) {
       return `战斗中无法进行队伍创建操作！`;
     }
     await BattleData.creatTeam(session);
   });
   ctx.command("队伍操作/队伍信息").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     const team = BattleData.teamListByUser(session.userId);
     if (!team.length) return `你还没有队伍...`;
     return `当前队伍信息如下：
 ` + team.map((item) => `lv.${item.lv} ${item.playName} [${BattleData.teamTemp[item.userId].identity}]`).join("\n");
   });
   ctx.command("队伍操作/队伍邀请 <playName>").action(async ({ session }, playName) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     if (BattleData.isBattle(session)) {
       return `战斗中无法进行队伍邀请操作！`;
     }
@@ -3002,23 +3307,42 @@ function apply(ctx, config) {
     await BattleData.invitationTeam(session, playName);
   });
   ctx.command("队伍操作/队伍加入").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     if (BattleData.isBattle(session)) {
       return `战斗中无法进行队伍创建操作！`;
     }
     await BattleData.joinTeam(session);
   });
   ctx.command("队伍操作/队伍退出").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     if (BattleData.isBattle(session)) {
       return `战斗中无法进行队伍退出操作！`;
     }
     await BattleData.exitTeam(session);
   });
   ctx.command("队伍操作/队伍解散").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
     if (BattleData.isBattle(session)) {
       return `战斗中无法进行队伍解散操作！`;
     }
     await BattleData.dissolveTeam(session);
   });
+  ctx.command("幻想乡/地图").action(async ({ session }) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    const { areaName, floor } = GensokyoMap.userCurrentLoal[session.userId];
+    const mapLocal = GensokyoMap.mapLocalData[floor];
+    const html = generateMapHTML(mapLocal, areaName);
+    console.log(html);
+    await session.send(await ctx.puppeteer.render(html));
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node: