koishi-plugin-smmcat-gensokyo 0.0.3 → 0.0.5

package/lib/battle.d.ts

@@ -1,5 +1,6 @@
 import { Context, Session } from "koishi";
 import { Config } from ".";
+import { UserBaseAttribute } from "./users";
 declare module 'koishi' {
     interface Tables {
         smm_gensokyo_battle_history: BattleHistory;
@@ -81,12 +82,15 @@ export type BattleAttribute = {
         name: string;
         time: number;
     }[];
+    /** 持有技能 */
+    fn?: [];
 };
 /** 最后战斗状态 */
 type LastPlay = {
     [keys: string]: {
         self: BattleAttribute[];
         goal: BattleAttribute[];
+        isPK?: boolean;
     };
 };
 export declare const BattleData: {
@@ -98,28 +102,40 @@ export declare const BattleData: {
     init(config: Config, ctx: Context): void;
     /** 玩家是否正在战斗 */
     isBattle(session: Session): boolean;
+    /** 玩家是否正在战斗 */
+    isBattleByUserId(userId: string): boolean;
     /** 玩家是否在队伍中 */
     isTeam(session: Session): boolean;
+    isTeamByUserId(userId: string): boolean;
+    teamListByUser(userId: string): UserBaseAttribute[];
     /** 创建战斗-与怪物 */
     createBattleByMonster(session: Session, goal: {
         name: string;
         lv: number;
     }[]): Promise<void>;
+    /** 创建战斗-与玩家 */
+    createBattleByUser(session: Session, goal: {
+        userId: string;
+    }[]): Promise<void>;
     /** 文本化当前战况 */
     battleSituationTextFormat(team: {
         self: BattleAttribute[];
         goal: BattleAttribute[];
+        isPK?: boolean;
     }): string;
     /** 判断输赢 */
     playOver(team: {
         self: BattleAttribute[];
         goal: BattleAttribute[];
+        isPK?: boolean;
     }): {
         over: boolean;
         type: string;
     };
     /** 清理战场 */
     clearBattleData(session: Session): void;
-    play(session: Session, atkType: "\u666E\u653B", select?: string): Promise<void>;
+    play(session: Session, atkType: string, select?: string): Promise<void>;
 };
+/**  获取阵容角色名 */
+export declare function getLineupName(agent: BattleAttribute): string;
 export {};

package/lib/damage.d.ts

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

package/lib/index.js

@@ -308,10 +308,24 @@ var GensokyoMap = {
     };
     fn && await fn(areaInfo);
     await delay(3e3);
-    GensokyoMap.setLocalStoragePoistionData(session.userId);
     userCurrentArea.moveing = false;
+    GensokyoMap.setLocalStoragePoistionData(session.userId);
     return;
   },
+  /** 查询附近玩家 */
+  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 = [];
@@ -786,7 +800,7 @@ var Damage = class {
     this.config = {
       agent: { self: { ...agent.self }, goal: { ...agent.goal } },
       harm: 0,
-      default_harm: agent.self.atk + agent.self.gain.atk,
+      default_harm: 0,
       isRealHarm: realHarm,
       isEvasion: false,
       isCsp: false,
@@ -795,13 +809,14 @@ var Damage = class {
   }
   /** 伤害判定前 */
   before(fn) {
+    this.config.default_harm = this.config.agent.self.atk + this.config.agent.self.gain.atk;
     fn && fn(this.config);
     return this;
   }
   /** 真实伤害判定 */
   beforRealHarm(fn) {
     fn && fn(this.config);
-    if (this.config.isEvasion) {
+    if (this.config.isRealHarm) {
       this.config.harm = this.config.default_harm;
     }
     return this;
@@ -877,6 +892,65 @@ function giveDamage(self, goal, damage) {
   }
 }
 __name(giveDamage, "giveDamage");
+function moreDamageInfo(damage) {
+  return (damage.isCsp ? `（暴击！）` : "") + (damage.isEvasion ? `（闪避成功！）` : "") + (damage.isBadDef ? `（未破防！）` : "");
+}
+__name(moreDamageInfo, "moreDamageInfo");
+
+// src/skillFn.ts
+var skillFn = {
+  "重砍": {
+    name: "重砍",
+    type: "伤害技" /* 伤害技 */,
+    info: "[伤害技]消耗10MP，对敌方一个单位造成基于攻击力1.2倍伤害。该次伤害无视敌方30%防御！（最低无视1防御）",
+    mp: 10,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      const damageData = new Damage(agent).result({
+        before: /* @__PURE__ */ __name((val) => {
+          val.default_harm += Math.floor(val.default_harm * 0.2);
+          val.agent.goal.def -= Math.floor(val.agent.goal.def * 0.3) || 1;
+        }, "before")
+      });
+      fn({
+        damage: damageData,
+        type: this.type,
+        target: [agent.goal],
+        isNext: false
+      });
+      return `${getLineupName(agent.self)} 释放重砍，对 ${getLineupName(agent.goal)} 造成 ${damageData.harm} 伤害。` + moreDamageInfo(damageData);
+    }, "fn")
+  },
+  "濒死一击": {
+    name: "濒死一击",
+    type: "伤害技" /* 伤害技 */,
+    info: "[伤害技]血量低于40%可释放，消耗20MP，对敌方一个单位造成基于攻击力2倍伤害。该次伤害暴击率提高20%",
+    mp: 20,
+    fn: /* @__PURE__ */ __name(function(agent, agentList, fn) {
+      if (agent.self.hp / (agent.self.maxHp + agent.self.gain.maxHp) < 0.4) {
+        const damageData = new Damage(agent).result({
+          before: /* @__PURE__ */ __name((val) => {
+            val.default_harm += val.default_harm;
+            val.agent.self.chr += 200;
+          }, "before")
+        });
+        fn({
+          damage: damageData,
+          type: this.type,
+          target: [agent.goal],
+          isNext: false
+        });
+        return `${getLineupName(agent.self)} 释放濒死一击，对 ${getLineupName(agent.goal)} 造成 ${damageData.harm} 伤害。` + moreDamageInfo(damageData);
+      } else {
+        fn({
+          type: "释放失败" /* 释放失败 */,
+          isNext: true,
+          err: "释放失败，未达成条件。"
+        });
+        return ``;
+      }
+    }, "fn")
+  }
+};
 
 // src/battle.ts
 var BattleData = {
@@ -893,10 +967,31 @@ var BattleData = {
   isBattle(session) {
     return !!BattleData.lastPlay[session.userId];
   },
+  /** 玩家是否正在战斗 */
+  isBattleByUserId(userId) {
+    return !!BattleData.lastPlay[userId];
+  },
   /** 玩家是否在队伍中 */
   isTeam(session) {
     return !!BattleData.teamTemp[session.userId];
   },
+  isTeamByUserId(userId) {
+    return !!BattleData.teamTemp[userId];
+  },
+  // 返回队伍信息
+  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 createBattleByMonster(session, goal) {
     if (BattleData.isBattle(session)) {
@@ -923,14 +1018,69 @@ var BattleData = {
     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] = {
-        self: battle_user.map((i) => ({ ...i, for: "self" })),
-        goal: battle_monsterList.map((i) => ({ ...i, for: "goal" }))
-      };
+      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 = [];
@@ -938,7 +1088,8 @@ var BattleData = {
     team.self.forEach((item) => {
       if (item.hp > 0) {
         selfTemp.push(`lv.${item.lv}[${item.name}]:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})`);
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
         selfTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
       }
@@ -946,11 +1097,17 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     team.goal.forEach((item) => {
       if (item.hp > 0) {
         goalTemp.push(`lv.${item.lv}[${item.name}]:
-${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})`);
+${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${item.maxHp + item.gain.maxHp})
+MP:${item.mp}/${item.maxMp + item.gain.maxMp}`);
       } else {
         goalTemp.push(`lv.${item.lv}[${item.name}]:已阵亡`);
       }
     });
+    if (team.isPK) {
+      return `[当前战况]
+攻击方：
+` + selfTemp.join("\n") + "\n\n防御方：\n" + goalTemp.join("\n");
+    }
     return `[当前战况]
 我方阵容：
 ` + selfTemp.join("\n") + "\n\n敌方阵容：\n" + goalTemp.join("\n");
@@ -962,19 +1119,20 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     if (self && goal) {
       return { over: true, type: "平局" };
     } else if (self) {
-      return { over: true, type: "敌方赢" };
+      return { over: true, type: team.isPK ? "防御方赢" : "敌方赢" };
     } else if (goal) {
-      return { over: true, type: "我方赢" };
+      return { over: true, type: team.isPK ? "攻击方赢" : "我方赢" };
     }
     return { over: false, type: "未结束" };
   },
   /** 清理战场 */
   clearBattleData(session) {
     if (BattleData.isTeam(session)) {
-      const userId = BattleData.teamTemp[session.userId].for;
-      Object.keys(BattleData.teamTemp).forEach((item) => {
-        if (BattleData.teamTemp[item].for == userId) {
-          delete BattleData.lastPlay[item];
+      const currentBattle = BattleData.lastPlay[session.userId];
+      const allAgentList = [...currentBattle.goal, ...currentBattle.self].sort((a, b) => b.speed - a.speed);
+      allAgentList.forEach((item) => {
+        if (item.type == "玩家") {
+          delete BattleData.lastPlay[item.userId];
         }
       });
     } else {
@@ -992,25 +1150,71 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     for (const agent of allAgentList) {
       if (agent.hp <= 0) continue;
       let lifeGoalList = [];
+      let lifeSelfList = [];
       if (agent.for == "self") {
         lifeGoalList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
+        lifeSelfList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
       } else {
         lifeGoalList = currentBattle.self.filter((item) => item.for == "self" && item.hp > 0);
+        lifeSelfList = currentBattle.goal.filter((item) => item.for == "goal" && item.hp > 0);
       }
       if (!lifeGoalList.length) continue;
       let selectGoal = {};
       let isMy = false;
+      let funType = "普攻";
       if (agent.type == "玩家" && agent.userId == session.userId) {
         isMy = true;
+        funType = atkType;
         selectGoal = lifeGoalList.find((item) => item.name == select) || lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
+      } else if (agent.type == "玩家") {
+        selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
       } else {
         selectGoal = lifeGoalList[Math.floor(Math.random() * lifeGoalList.length)];
       }
-      const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
-      giveDamage(agent, selectGoal, damageInfo);
-      msgList.push(
-        `[${agent.type}]${agent.name} 使用普攻攻击了 [${selectGoal.type}]${selectGoal.name}，造成了${damageInfo.harm}伤害。` + (damageInfo.isCsp ? `（暴击！）` : "") + (damageInfo.isEvasion ? `（闪避成功！）` : "") + (damageInfo.isBadDef ? `（未破防！）` : "")
-      );
+      const noralAtk = /* @__PURE__ */ __name(() => {
+        const damageInfo = new Damage({ self: agent, goal: selectGoal }).result();
+        giveDamage(agent, selectGoal, damageInfo);
+        msgList.push(
+          `${getLineupName(agent)} 使用普攻攻击了 ${getLineupName(selectGoal)}，造成了${damageInfo.harm}伤害。` + moreDamageInfo(damageInfo)
+        );
+      }, "noralAtk");
+      if (funType == "普攻") {
+        noralAtk();
+      } else {
+        if (skillFn[atkType]) {
+          const selectFn = skillFn[atkType];
+          if (selectFn.mp == 0 || agent.mp - selectFn.mp >= 0) {
+            agent.mp -= selectFn.mp;
+            let isNext = false;
+            const fnMsg = selectFn.fn(
+              { self: agent, goal: selectGoal },
+              { selfList: lifeSelfList, goalList: lifeGoalList },
+              (val) => {
+                switch (val.type) {
+                  case "伤害技" /* 伤害技 */:
+                    val.target.map((goal) => {
+                      giveDamage(agent, goal, val.damage);
+                    });
+                    break;
+                  case "释放失败" /* 释放失败 */:
+                    val.err && session.send(val.err);
+                  default:
+                    break;
+                }
+                isNext = val.isNext;
+              }
+            );
+            fnMsg && msgList.push(fnMsg);
+            isNext && noralAtk();
+          } else {
+            await session.send(`MP不足，释放失败！`);
+            noralAtk();
+          }
+        } else {
+          await session.send(`未持有该技能或者该技能不存在，释放失败！`);
+          noralAtk();
+        }
+      }
     }
     await session.send(msgList.length ? `战斗记录：
 ` + msgList.join("\n") : "");
@@ -1022,6 +1226,10 @@ ${generateHealthDisplay(item.hp, item.maxHp + item.gain.maxHp)}(${item.hp}/${ite
     }
   }
 };
+function getLineupName(agent) {
+  return `[${agent.type}]${agent.name}`;
+}
+__name(getLineupName, "getLineupName");
 function initBattleAttribute(data) {
   if ("playName" in data) {
     const userData = data;
@@ -1053,7 +1261,8 @@ function initBattleAttribute(data) {
         hit: 0,
         speed: 0
       },
-      buff: []
+      buff: [],
+      fn: []
     };
     return temp;
   } else {
@@ -1085,7 +1294,8 @@ function initBattleAttribute(data) {
         hit: 0,
         speed: 0
       },
-      buff: []
+      buff: [],
+      fn: []
     };
     return temp;
   }
@@ -1219,7 +1429,7 @@ function apply(ctx, config) {
     GensokyoMap.initUserPoistion(session, userData);
     const areaInfo = GensokyoMap.getUserCurrentArea(session.userId);
     if (goal) {
-      if (!areaInfo.monster.map((i) => i.name).includes(goal)) {
+      if (!areaInfo.monster?.map((i) => i.name).includes(goal)) {
         return `没有在该区域找到该怪物。`;
       }
       const selectMonster = areaInfo.monster.find((i) => i.name == goal);
@@ -1234,6 +1444,40 @@ function apply(ctx, config) {
     if (!userData) return;
     BattleData.play(session, "普攻", goal);
   });
+  ctx.command("幻想乡/打怪技能 <skill> <goal>").action(async ({ session }, skill, goal) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    BattleData.play(session, skill, goal);
+  });
+  ctx.command("打怪pk <goal>").action(async ({ session }, goal) => {
+    const userData = await User.getUserAttribute(session);
+    if (!userData) return;
+    GensokyoMap.initUserPoistion(session, userData);
+    if (!goal) {
+      await session.send("请选择PK目标！");
+      return;
+    }
+    const nearUserItem = GensokyoMap.nearbyPlayersByUserId(session.userId);
+    const exist = nearUserItem.find((item) => item.playName == goal.trim());
+    if (!exist) {
+      await session.send(`PK失败，当前区域未存在【${goal}】玩家`);
+      return;
+    }
+    if (BattleData.isTeamByUserId(exist.userId)) {
+      const teamItem = BattleData.teamListByUser(exist.userId);
+      await session.send(`对方有组队，您将扮演攻击方与对方队伍进行战斗。`);
+      await BattleData.createBattleByUser(session, teamItem.map((item) => ({ userId: item.userId })));
+    } else {
+      await session.send(`您将扮演攻击方与对方进行战斗。`);
+      await BattleData.createBattleByUser(session, [{ userId: exist.userId }]);
+    }
+  });
+  ctx.command("技能查询 <goal>").action(async ({ session }, goal) => {
+    if (!goal) return `请输入技能名，例如 /技能查询 重砍`;
+    if (!skillFn[goal]) return `没有存在 ${goal} 技能！`;
+    return `[${goal}]信息如下：
+` + skillFn[goal].info;
+  });
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:

package/lib/map.d.ts

@@ -98,6 +98,11 @@ export declare const GensokyoMap: {
     setLocalStoragePoistionData(userId: string): Promise<void>;
     /** 用户移动 */
     move(session: Session, type: MoveType, fn?: (area: AreaCallbackData) => Promise<void>): Promise<void>;
+    /** 查询附近玩家 */
+    nearbyPlayersByUserId(userId: string): {
+        userId: string;
+        playName: string;
+    }[];
     /** 区域信息格式化 */
     userAreaTextFormat(gameName: string, data: AreaCallbackData): string;
 };

package/lib/skillFn.d.ts

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

package/lib/test.d.ts

@@ -0,0 +1,5 @@
+declare const nameList: {
+    张三: {};
+    李四: {};
+};
+declare const fn: (name: any) => any;

package/package.json

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