koishi-plugin-maple-warriors 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,47 @@
+import { Context, Schema } from 'koishi';
+export declare const using: readonly ["database"];
+declare module 'koishi' {
+    interface Tables {
+        maple_warriors: MapleWarrior;
+        maple_warriors_items: MapleItem;
+    }
+}
+export interface MapleWarrior {
+    id: number;
+    userId: string;
+    name: string;
+    level: number;
+    constitution: number;
+    attack: number;
+    toughness: number;
+    crit: number;
+    agility: number;
+    currentHp: number;
+    maxHp: number;
+    status: string;
+    previousStatus: string;
+    statusEndTime: Date | null;
+    items: string;
+    lastTrainDate: string;
+    lastHuntDate: string;
+    updatedAt: Date;
+}
+export interface MapleItem {
+    id: number;
+    name: string;
+    hpBonus: number;
+    constitutionBonus: number;
+    attackBonus: number;
+    toughnessBonus: number;
+    critBonus: number;
+    agilityBonus: number;
+    description: string;
+    createdAt: Date;
+}
+export declare const name = "maple-warriors";
+export interface Config {
+    preyData: string[];
+    battleMessageInterval: number;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,1017 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name,
+  using: () => using
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var using = ["database"];
+var name = "maple-warriors";
+var DEFAULT_PREY_DATA = [
+  "老鼠 5 1 1 1 1 1-20",
+  "野兔 1 3-5 2-4 2-4 1-3 5-50"
+];
+var Config = import_koishi.Schema.object({
+  preyData: import_koishi.Schema.array(import_koishi.Schema.string()).role("table").default(DEFAULT_PREY_DATA).description("猎物数据，每行格式：猎物名 权重 体质 攻击 韧性 暴击 敏捷（权重是固定数值，属性可以是固定数值或范围，如1-10）"),
+  battleMessageInterval: import_koishi.Schema.number().min(1).max(5).default(2).description("战斗消息发送间隔（秒）")
+});
+function calculateRates(character) {
+  const resistance = (character.toughness / (character.toughness + 90)).toFixed(4);
+  const critRate = (character.crit / (character.crit + 90)).toFixed(4);
+  const chargeTime = (1 + 280 / (character.agility + 70)).toFixed(2);
+  const dodgeRate = (0.2 * character.agility / (character.agility + 90)).toFixed(4);
+  return { resistance, critRate, chargeTime, dodgeRate };
+}
+__name(calculateRates, "calculateRates");
+var BattleManager = class {
+  static {
+    __name(this, "BattleManager");
+  }
+  battles = /* @__PURE__ */ new Map();
+  startBattle(channelId, playerHp, preyName) {
+    if (this.isBattling(channelId)) {
+      return false;
+    }
+    this.battles.set(channelId, {
+      isBattling: true,
+      abortController: new AbortController(),
+      playerHp,
+      preyName
+    });
+    return true;
+  }
+  endBattle(channelId, finalPlayerHp) {
+    const battle = this.battles.get(channelId);
+    if (battle && battle.isBattling) {
+      if (battle.abortController) {
+        battle.abortController.abort();
+      }
+      if (finalPlayerHp !== void 0) {
+        battle.playerHp = finalPlayerHp;
+      }
+      this.battles.delete(channelId);
+      return true;
+    }
+    return false;
+  }
+  isBattling(channelId) {
+    return this.battles.has(channelId) && this.battles.get(channelId).isBattling;
+  }
+  getAbortController(channelId) {
+    return this.battles.get(channelId)?.abortController;
+  }
+  getBattleData(channelId) {
+    return this.battles.get(channelId);
+  }
+};
+function parseAttributeRange(value) {
+  if (value.includes("-")) {
+    const [min, max] = value.split("-").map((v) => parseInt(v.trim()));
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+  return parseInt(value) || 1;
+}
+__name(parseAttributeRange, "parseAttributeRange");
+function parseItemsString(itemsStr) {
+  if (!itemsStr) return {};
+  try {
+    return JSON.parse(itemsStr);
+  } catch {
+    return {};
+  }
+}
+__name(parseItemsString, "parseItemsString");
+function serializeItems(items) {
+  return JSON.stringify(items);
+}
+__name(serializeItems, "serializeItems");
+function formatRemainingTime(endTime) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = endTime.getTime() - now.getTime();
+  if (diffMs <= 0) return "0秒";
+  const hours = Math.floor(diffMs / (1e3 * 60 * 60));
+  const minutes = Math.floor(diffMs % (1e3 * 60 * 60) / (1e3 * 60));
+  const seconds = Math.floor(diffMs % (1e3 * 60) / 1e3);
+  const parts = [];
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+  return parts.join("");
+}
+__name(formatRemainingTime, "formatRemainingTime");
+function getTodayDateString() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toISOString().split("T")[0];
+}
+__name(getTodayDateString, "getTodayDateString");
+function isSameDay(dateString1, dateString2) {
+  return dateString1 === dateString2;
+}
+__name(isSameDay, "isSameDay");
+function generateRandomAttributes() {
+  let points = 25 - 5;
+  const attributes = {
+    constitution: 1,
+    attack: 1,
+    toughness: 1,
+    crit: 1,
+    agility: 1
+  };
+  const keys = ["constitution", "attack", "toughness", "crit", "agility"];
+  for (let i = 0; i < points; i++) {
+    const randomAttr = keys[Math.floor(Math.random() * keys.length)];
+    attributes[randomAttr]++;
+  }
+  return attributes;
+}
+__name(generateRandomAttributes, "generateRandomAttributes");
+function parsePreyData(preyData) {
+  const preyList = [];
+  for (const line of preyData) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length === 7) {
+      preyList.push({
+        name: parts[0],
+        weight: parseInt(parts[1]) || 1,
+        constitution: parts[2],
+        attack: parts[3],
+        toughness: parts[4],
+        crit: parts[5],
+        agility: parts[6]
+      });
+    } else {
+      console.error("猎物数据格式错误:", line);
+    }
+  }
+  return preyList;
+}
+__name(parsePreyData, "parsePreyData");
+function selectRandomPrey(preyList) {
+  const totalWeight = preyList.reduce((sum, prey) => sum + prey.weight, 0);
+  let random = Math.random() * totalWeight;
+  for (const prey of preyList) {
+    random -= prey.weight;
+    if (random <= 0) {
+      return prey;
+    }
+  }
+  return preyList[0];
+}
+__name(selectRandomPrey, "selectRandomPrey");
+function apply(ctx, config) {
+  const battleManager = new BattleManager();
+  ctx.model.extend("maple_warriors", {
+    id: "unsigned",
+    userId: "string",
+    name: "string",
+    level: "unsigned",
+    constitution: "unsigned",
+    attack: "unsigned",
+    toughness: "unsigned",
+    crit: "unsigned",
+    agility: "unsigned",
+    currentHp: "unsigned",
+    maxHp: "unsigned",
+    status: "string",
+    previousStatus: "string",
+    statusEndTime: "timestamp",
+    items: "text",
+    lastTrainDate: "string",
+    lastHuntDate: "string",
+    updatedAt: "timestamp"
+  }, {
+    primary: "id",
+    autoInc: true
+  });
+  ctx.model.extend("maple_warriors_items", {
+    id: "unsigned",
+    name: "string",
+    hpBonus: "integer",
+    constitutionBonus: "integer",
+    attackBonus: "integer",
+    toughnessBonus: "integer",
+    critBonus: "integer",
+    agilityBonus: "integer",
+    description: "string",
+    createdAt: "timestamp"
+  }, {
+    primary: "id",
+    autoInc: true,
+    unique: ["name"]
+  });
+  async function formatCharacterInfo(character) {
+    const rates = calculateRates({
+      toughness: character.toughness,
+      crit: character.crit,
+      agility: character.agility
+    });
+    const items = parseItemsString(character.items);
+    const itemsText = Object.entries(items).map(([name2, count]) => `${name2}*${count}`).join("\n");
+    return `名字: ${character.name}
+等级: ${character.level}
+体质: ${character.constitution} (HP: ${character.currentHp}/${character.maxHp})
+攻击: ${character.attack}
+韧性: ${character.toughness} (抗性: ${(parseFloat(rates.resistance) * 100).toFixed(2)}%)
+暴击: ${character.crit} (暴击率: ${(parseFloat(rates.critRate) * 100).toFixed(2)}%)
+敏捷: ${character.agility} (蓄力: ${rates.chargeTime}s 闪避率: ${(parseFloat(rates.dodgeRate) * 100).toFixed(2)}%)
+状态: ${character.status}${character.statusEndTime ? " 剩余" + formatRemainingTime(character.statusEndTime) : ""}
+──────────
+物品栏:
+${itemsText || "空空如也"}`;
+  }
+  __name(formatCharacterInfo, "formatCharacterInfo");
+  async function getOrCreateCharacter(userId, name2) {
+    let characters = await ctx.database.get("maple_warriors", { userId });
+    if (characters.length === 0) {
+      const attributes = generateRandomAttributes();
+      const maxHp = attributes.constitution * 5;
+      const character = {
+        userId,
+        name: name2 || '请输入"修改名字 角色名"修改',
+        level: 1,
+        constitution: attributes.constitution,
+        attack: attributes.attack,
+        toughness: attributes.toughness,
+        crit: attributes.crit,
+        agility: attributes.agility,
+        currentHp: maxHp,
+        maxHp,
+        status: "无",
+        previousStatus: "无",
+        statusEndTime: null,
+        items: "{}",
+        lastTrainDate: "",
+        lastHuntDate: "",
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await ctx.database.create("maple_warriors", character);
+      characters = await ctx.database.get("maple_warriors", { userId });
+    }
+    return characters[0];
+  }
+  __name(getOrCreateCharacter, "getOrCreateCharacter");
+  function checkCharacterStatus(character) {
+    const now = /* @__PURE__ */ new Date();
+    if (character.statusEndTime && now >= character.statusEndTime) {
+      const updates = {
+        status: "无",
+        previousStatus: "无",
+        statusEndTime: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (character.status === "睡眠" || character.status === "治疗") {
+        updates.currentHp = character.maxHp;
+      }
+      ctx.database.set("maple_warriors", { id: character.id }, updates);
+      return { canAct: true, message: "" };
+    }
+    if (character.status === "受伤") {
+      return { canAct: false, message: '你受伤了，快输入"治疗"吧！' };
+    }
+    if (character.status === "睡眠") {
+      return { canAct: false, message: "你想在梦里做这个吗？" };
+    }
+    if (character.status === "治疗") {
+      return { canAct: false, message: "正在治疗中，请好好养伤！" };
+    }
+    return { canAct: true, message: "" };
+  }
+  __name(checkCharacterStatus, "checkCharacterStatus");
+  ctx.command("猫武士", "猫武士插件 - 帮助菜单");
+  ctx.command("猫武士/修改名字 <name>", "修改角色名字").example("修改名字 火焰猫").example("修改名字 闪电虎").action(async ({ session }, name2) => {
+    if (!name2 || name2.trim().length === 0) {
+      return "格式错误！正确格式：修改名字 角色名";
+    }
+    const userId = session.userId;
+    const trimmedName = name2.trim();
+    let characters = await ctx.database.get("maple_warriors", { userId });
+    if (characters.length === 0) {
+      const attributes = generateRandomAttributes();
+      const maxHp = attributes.constitution * 5;
+      const character = {
+        userId,
+        name: trimmedName,
+        level: 1,
+        constitution: attributes.constitution,
+        attack: attributes.attack,
+        toughness: attributes.toughness,
+        crit: attributes.crit,
+        agility: attributes.agility,
+        currentHp: maxHp,
+        maxHp,
+        status: "无",
+        previousStatus: "无",
+        statusEndTime: null,
+        items: "{}",
+        lastTrainDate: "",
+        lastHuntDate: "",
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await ctx.database.create("maple_warriors", character);
+    } else {
+      await ctx.database.set("maple_warriors", { userId }, {
+        name: trimmedName,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return "修改成功！";
+  });
+  ctx.command("猫武士/我的角色", "查看我的角色信息").example("我的角色").action(async ({ session }) => {
+    const userId = session.userId;
+    let character = await getOrCreateCharacter(userId);
+    return await formatCharacterInfo(character);
+  });
+  ctx.command("猫武士/训练 <attrs>", "训练提升属性").example("训练 体质 体质 攻击").example("训练 体质").example("训练 随机").action(async ({ session }, attrs) => {
+    const userId = session.userId;
+    let character = await getOrCreateCharacter(userId);
+    const statusCheck = checkCharacterStatus(character);
+    if (!statusCheck.canAct) {
+      return statusCheck.message;
+    }
+    const today = getTodayDateString();
+    if (character.lastTrainDate && isSameDay(character.lastTrainDate, today)) {
+      return "今天已经训练过了，要注意劳逸结合哦！";
+    }
+    if (!attrs) {
+      return "格式错误！正确格式：训练 属性1 属性2 属性3（可重复，若只指定一项，则其余两项随机提升）或 训练 随机";
+    }
+    const attrList = attrs.trim().split(/\s+/);
+    if (attrList.length === 1 && attrList[0] === "随机") {
+      const validAttrs2 = ["体质", "攻击", "韧性", "暴击", "敏捷"];
+      const attrMap2 = {
+        "体质": "constitution",
+        "攻击": "attack",
+        "韧性": "toughness",
+        "暴击": "crit",
+        "敏捷": "agility"
+      };
+      const updates2 = {};
+      const attributeCounts2 = {};
+      for (let i = 0; i < 3; i++) {
+        const randomAttr = validAttrs2[Math.floor(Math.random() * validAttrs2.length)];
+        const field = attrMap2[randomAttr];
+        updates2[field] = (updates2[field] || character[field] || 0) + 1;
+        attributeCounts2[randomAttr] = (attributeCounts2[randomAttr] || 0) + 1;
+      }
+      const changes2 = [];
+      for (const [attr, count] of Object.entries(attributeCounts2)) {
+        changes2.push(`${attr}+${count}`);
+      }
+      updates2.lastTrainDate = today;
+      updates2.updatedAt = /* @__PURE__ */ new Date();
+      await ctx.database.set("maple_warriors", { userId }, updates2);
+      return `训练成功！你好像领悟了什么……
+${changes2.join(" ")}`;
+    }
+    if (attrList.length > 3) {
+      return "只能指定3个属性（可以重复），不要太贪心哦！";
+    }
+    const validAttrs = ["体质", "攻击", "韧性", "暴击", "敏捷"];
+    const attrMap = {
+      "体质": "constitution",
+      "攻击": "attack",
+      "韧性": "toughness",
+      "暴击": "crit",
+      "敏捷": "agility"
+    };
+    for (const attr of attrList) {
+      if (!validAttrs.includes(attr)) {
+        return `属性名错误！有效的属性有：${validAttrs.join("、")}`;
+      }
+    }
+    const updates = {};
+    const attributeCounts = {};
+    for (const attr of attrList) {
+      const field = attrMap[attr];
+      updates[field] = (updates[field] || character[field] || 0) + 1;
+      attributeCounts[attr] = (attributeCounts[attr] || 0) + 1;
+    }
+    for (let i = 0; i < 3 - attrList.length; i++) {
+      const randomAttr = validAttrs[Math.floor(Math.random() * validAttrs.length)];
+      const field = attrMap[randomAttr];
+      updates[field] = (updates[field] || character[field] || 0) + 1;
+      attributeCounts[randomAttr] = (attributeCounts[randomAttr] || 0) + 1;
+    }
+    const changes = [];
+    for (const [attr, count] of Object.entries(attributeCounts)) {
+      changes.push(`${attr}+${count}`);
+    }
+    updates.lastTrainDate = today;
+    updates.updatedAt = /* @__PURE__ */ new Date();
+    await ctx.database.set("maple_warriors", { userId }, updates);
+    return `训练成功！你好像领悟了什么……
+${changes.join(" ")}`;
+  });
+  ctx.command("猫武士/捕猎", "捕猎随机猎物").example("捕猎").action(async ({ session }) => {
+    const channelId = session.channelId;
+    const userId = session.userId;
+    if (battleManager.isBattling(channelId)) {
+      return "请等待当前战斗结束！";
+    }
+    let character = await getOrCreateCharacter(userId);
+    const statusCheck = checkCharacterStatus(character);
+    if (!statusCheck.canAct) {
+      return statusCheck.message;
+    }
+    const today = getTodayDateString();
+    if (character.lastHuntDate && isSameDay(character.lastHuntDate, today)) {
+      return "今天已经捕猎过了，要注意劳逸结合哦！";
+    }
+    const preyList = parsePreyData(config.preyData);
+    if (preyList.length === 0) {
+      return "未找到猎物数据，请在控制台配置猎物数据。";
+    }
+    const selectedPrey = selectRandomPrey(preyList);
+    const constitution = parseAttributeRange(selectedPrey.constitution);
+    const attack = parseAttributeRange(selectedPrey.attack);
+    const toughness = parseAttributeRange(selectedPrey.toughness);
+    const crit = parseAttributeRange(selectedPrey.crit);
+    const agility = parseAttributeRange(selectedPrey.agility);
+    const preyHp = constitution * 5;
+    const chargeTime = parseFloat((1 + 280 / (agility + 70)).toFixed(2));
+    const prey = {
+      name: selectedPrey.name,
+      constitution,
+      attack,
+      toughness,
+      crit,
+      agility,
+      hp: preyHp,
+      maxHp: preyHp,
+      chargeTime,
+      nextAttackTime: chargeTime
+    };
+    if (!battleManager.startBattle(channelId, character.currentHp, selectedPrey.name)) {
+      return "战斗开始失败，请重试！";
+    }
+    const preyRates = calculateRates({
+      toughness: prey.toughness,
+      crit: prey.crit,
+      agility: prey.agility
+    });
+    await session.send(`发现猎物: ${prey.name}
+体质: ${prey.constitution} (HP: ${prey.hp})
+攻击: ${prey.attack}
+韧性: ${prey.toughness} (抗性: ${(parseFloat(preyRates.resistance) * 100).toFixed(2)}%)
+暴击: ${prey.crit} (暴击率: ${(parseFloat(preyRates.critRate) * 100).toFixed(2)}%)
+敏捷: ${prey.agility} (蓄力: ${preyRates.chargeTime}s 闪避率: ${(parseFloat(preyRates.dodgeRate) * 100).toFixed(2)}%)`);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    const abortController = battleManager.getAbortController(channelId);
+    try {
+      const player = {
+        name: character.name,
+        constitution: character.constitution,
+        attack: character.attack,
+        toughness: character.toughness,
+        crit: character.crit,
+        agility: character.agility,
+        hp: character.currentHp,
+        maxHp: character.maxHp,
+        chargeTime: parseFloat((1 + 280 / (character.agility + 70)).toFixed(2)),
+        nextAttackTime: 0
+      };
+      const today2 = getTodayDateString();
+      const updates = {
+        lastHuntDate: today2,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      if (player.hp <= 0) {
+        updates.status = "受伤";
+        updates.previousStatus = "无";
+        updates.statusEndTime = null;
+        updates.currentHp = 0;
+      } else {
+        updates.currentHp = player.hp;
+        if (prey.hp <= 0) {
+          const items = parseItemsString(character.items);
+          items[selectedPrey.name] = (items[selectedPrey.name] || 0) + 1;
+          updates.items = serializeItems(items);
+        }
+      }
+      await ctx.database.set("maple_warriors", { userId }, updates);
+    } catch (error) {
+      if (error.name === "AbortError") {
+        const today2 = getTodayDateString();
+        await ctx.database.set("maple_warriors", { userId }, {
+          lastHuntDate: today2,
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+      } else {
+        throw error;
+      }
+    } finally {
+      battleManager.endBattle(channelId);
+    }
+  });
+  ctx.command("猫武士/使用物品 <itemInput>", "使用物品栏中的物品").example("使用物品 老鼠").example("使用物品 老鼠 2").example("使用物品 老鼠*2").action(async ({ session }, itemInput) => {
+    if (!itemInput) {
+      return "格式错误！正确格式：使用物品 物品名 数量 或 使用物品 物品名*数量";
+    }
+    const userId = session.userId;
+    let character = await getOrCreateCharacter(userId);
+    const statusCheck = checkCharacterStatus(character);
+    if (!statusCheck.canAct) {
+      return statusCheck.message;
+    }
+    let itemName = "";
+    let count = 1;
+    if (itemInput.includes("*")) {
+      const parts = itemInput.split("*");
+      itemName = parts[0].trim();
+      count = parseInt(parts[1]) || 1;
+    } else {
+      const parts = itemInput.trim().split(/\s+/);
+      itemName = parts[0];
+      if (parts[1]) {
+        count = parseInt(parts[1]) || 1;
+      }
+    }
+    if (!itemName) {
+      return "格式错误！正确格式：使用物品 物品名 数量 或 使用物品 物品名*数量";
+    }
+    const items = parseItemsString(character.items);
+    if (!items[itemName] || items[itemName] < count) {
+      return `使用失败！${!items[itemName] ? `梦里才有${itemName}吧……` : `没有那么多${itemName}！`}`;
+    }
+    const itemInfo = await ctx.database.get("maple_warriors_items", { name: itemName });
+    const item = itemInfo.length > 0 ? itemInfo[0] : null;
+    items[itemName] -= count;
+    if (items[itemName] <= 0) {
+      delete items[itemName];
+    }
+    const updates = {
+      items: serializeItems(items),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    const changes = [];
+    if (item) {
+      if (item.hpBonus) {
+        let newHp = character.currentHp + item.hpBonus * count;
+        if (newHp > character.maxHp) newHp = character.maxHp;
+        if (newHp < 0) newHp = 0;
+        updates.currentHp = newHp;
+        changes.push(`HP+${item.hpBonus * count}`);
+      }
+      if (item.constitutionBonus) {
+        updates.constitution = character.constitution + item.constitutionBonus * count;
+        changes.push(`体质+${item.constitutionBonus * count}`);
+      }
+      if (item.attackBonus) {
+        updates.attack = character.attack + item.attackBonus * count;
+        changes.push(`攻击+${item.attackBonus * count}`);
+      }
+      if (item.toughnessBonus) {
+        updates.toughness = character.toughness + item.toughnessBonus * count;
+        changes.push(`韧性+${item.toughnessBonus * count}`);
+      }
+      if (item.critBonus) {
+        updates.crit = character.crit + item.critBonus * count;
+        changes.push(`暴击+${item.critBonus * count}`);
+      }
+      if (item.agilityBonus) {
+        updates.agility = character.agility + item.agilityBonus * count;
+        changes.push(`敏捷+${item.agilityBonus * count}`);
+      }
+      if (updates.constitution) {
+        updates.maxHp = updates.constitution * 5;
+      }
+    }
+    await ctx.database.set("maple_warriors", { userId }, updates);
+    const changesText = changes.length > 0 ? "\n" + changes.join(" ") : "";
+    return `使用成功！消耗了${itemName}*${count}${changesText}`;
+  });
+  ctx.command("猫武士/睡眠", "让角色进入睡眠状态").example("睡眠").action(async ({ session }) => {
+    const userId = session.userId;
+    let character = await getOrCreateCharacter(userId);
+    const statusCheck = checkCharacterStatus(character);
+    if (!statusCheck.canAct) {
+      return statusCheck.message;
+    }
+    const endTime = /* @__PURE__ */ new Date();
+    endTime.setHours(endTime.getHours() + 4);
+    await ctx.database.set("maple_warriors", { userId }, {
+      status: "睡眠",
+      previousStatus: character.status,
+      // 保存之前的状态
+      statusEndTime: endTime,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return `进入睡眠状态，剩余4h0m0s`;
+  });
+  ctx.command("猫武士/治疗", "治疗受伤的角色").example("治疗").action(async ({ session }) => {
+    const userId = session.userId;
+    let character = await getOrCreateCharacter(userId);
+    if (character.currentHp > 0 && character.status !== "受伤") {
+      return "你的状态良好，无需治疗。";
+    }
+    const endTime = /* @__PURE__ */ new Date();
+    endTime.setHours(endTime.getHours() + 4);
+    await ctx.database.set("maple_warriors", { userId }, {
+      status: "治疗",
+      previousStatus: character.status,
+      // 保存之前的状态
+      statusEndTime: endTime,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    return `进入治疗状态，剩余4h0m0s`;
+  });
+  ctx.command("猫武士/结束 <action>", "结束当前状态").example("结束 战斗").example("结束 睡眠").example("结束 治疗").action(async ({ session }, action) => {
+    if (!action) {
+      return "格式错误！正确格式：结束 战斗/睡眠/治疗";
+    }
+    const userId = session.userId;
+    const channelId = session.channelId;
+    switch (action) {
+      case "战斗":
+        if (battleManager.isBattling(channelId)) {
+          const battleData = battleManager.getBattleData(channelId);
+          if (battleData && battleData.playerHp !== void 0 && !battleData.isTraining) {
+            await ctx.database.set("maple_warriors", { userId }, {
+              currentHp: battleData.playerHp,
+              updatedAt: /* @__PURE__ */ new Date()
+            });
+          }
+          battleManager.endBattle(channelId);
+        } else {
+          return "当前没有正在进行的战斗。";
+        }
+      case "睡眠":
+      case "治疗":
+        let character = await getOrCreateCharacter(userId);
+        if (character.status === action) {
+          await ctx.database.set("maple_warriors", { userId }, {
+            status: character.previousStatus || "无",
+            previousStatus: "无",
+            statusEndTime: null,
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+          return `结束了当前的${action}`;
+        } else {
+          return `当前没有处于${action}状态。`;
+        }
+      default:
+        return "格式错误！正确格式：结束 战斗/睡眠/治疗";
+    }
+  });
+  ctx.command("猫武士/查询物品 <itemName>", "查询物品信息").example("查询物品 老鼠").action(async ({ session }, itemName) => {
+    if (!itemName) {
+      return "格式错误！正确格式：查询物品 物品名";
+    }
+    const items = await ctx.database.get("maple_warriors_items", { name: itemName });
+    if (items.length === 0) {
+      return `物品表中没有${itemName}！`;
+    }
+    const item = items[0];
+    const bonuses = [];
+    if (item.hpBonus) bonuses.push(`HP+${item.hpBonus}`);
+    if (item.constitutionBonus) bonuses.push(`体质+${item.constitutionBonus}`);
+    if (item.attackBonus) bonuses.push(`攻击+${item.attackBonus}`);
+    if (item.toughnessBonus) bonuses.push(`韧性+${item.toughnessBonus}`);
+    if (item.critBonus) bonuses.push(`暴击+${item.critBonus}`);
+    if (item.agilityBonus) bonuses.push(`敏捷+${item.agilityBonus}`);
+    let result = `物品: ${item.name}
+`;
+    if (bonuses.length > 0) {
+      result += bonuses.join(" ") + "\n";
+    }
+    if (item.description) {
+      result += `"${item.description}"`;
+    }
+    return result.trim();
+  });
+  ctx.command("猫武士/添加物品 <...args>", "添加或修改物品").example("添加物品 老鼠 体质 1 很常见的老鼠").example("添加物品 治疗药水 hp 10 恢复生命值").action(async ({ session }, ...args) => {
+    if (args.length < 1) {
+      return "格式错误！正确格式：添加物品 物品名 [属性 增加数 ...] [介绍]";
+    }
+    let itemName = args[0];
+    let description = "";
+    const updates = {
+      hpBonus: 0,
+      constitutionBonus: 0,
+      attackBonus: 0,
+      toughnessBonus: 0,
+      critBonus: 0,
+      agilityBonus: 0
+    };
+    let i = 1;
+    const validAttrs = ["HP", "hp", "体质", "攻击", "韧性", "暴击", "敏捷"];
+    const attrMap = {
+      "HP": "hpBonus",
+      "hp": "hpBonus",
+      "体质": "constitutionBonus",
+      "攻击": "attackBonus",
+      "韧性": "toughnessBonus",
+      "暴击": "critBonus",
+      "敏捷": "agilityBonus"
+    };
+    while (i < args.length) {
+      const arg = args[i];
+      const normalizedAttr = arg.toLowerCase() === "hp" ? "HP" : arg;
+      if (!validAttrs.includes(normalizedAttr)) {
+        description = args.slice(i).join(" ");
+        break;
+      }
+      if (i + 1 >= args.length) {
+        return `格式错误！属性"${arg}"缺少数值`;
+      }
+      const nextArg = args[i + 1];
+      const value = parseInt(nextArg);
+      if (isNaN(value)) {
+        const nextNormalized = nextArg.toLowerCase() === "hp" ? "HP" : nextArg;
+        if (validAttrs.includes(nextNormalized)) {
+          return `格式错误！属性"${arg}"缺少数值`;
+        } else {
+          description = args.slice(i + 1).join(" ");
+          break;
+        }
+      }
+      const fieldName = attrMap[normalizedAttr];
+      if (fieldName) {
+        updates[fieldName] = value;
+      } else {
+        return `属性名错误！有效的属性有：${["HP", "体质", "攻击", "韧性", "暴击", "敏捷"].join("、")}`;
+      }
+      i += 2;
+    }
+    const existingItems = await ctx.database.get("maple_warriors_items", { name: itemName });
+    if (existingItems.length > 0) {
+      await ctx.database.set("maple_warriors_items", { name: itemName }, {
+        ...updates,
+        description,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      return `修改${itemName}成功！`;
+    } else {
+      await ctx.database.create("maple_warriors_items", {
+        name: itemName,
+        ...updates,
+        description,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+      return `添加${itemName}成功！`;
+    }
+  });
+  ctx.command("猫武士/物品列表 [page]", "查看物品列表").example("物品列表").example("物品列表 2").action(async ({ session }, page = "1") => {
+    const pageNum = parseInt(page) || 1;
+    if (pageNum < 1) {
+      return "页码必须大于0！";
+    }
+    const allItems = await ctx.database.get("maple_warriors_items", {});
+    allItems.sort((a, b) => a.name.localeCompare(b.name));
+    const pageSize = 10;
+    const totalPages = Math.ceil(allItems.length / pageSize);
+    if (pageNum > totalPages && totalPages > 0) {
+      return `页码超出范围！总页数：${totalPages}`;
+    }
+    const startIndex = (pageNum - 1) * pageSize;
+    const pageItems = allItems.slice(startIndex, startIndex + pageSize);
+    let output = `物品列表 第 ${pageNum}/${totalPages} 页（共 ${allItems.length} 个物品）
+
+`;
+    pageItems.forEach((item, index) => {
+      const displayIndex = startIndex + index + 1;
+      output += `${displayIndex}. ${item.name}
+`;
+    });
+    output += "\n──────────\n";
+    if (pageNum > 1) {
+      output += `输入"物品列表 ${pageNum - 1}"查看上一页
+`;
+    }
+    if (pageNum < totalPages) {
+      output += `输入"物品列表 ${pageNum + 1}"查看下一页
+`;
+    }
+    output += `输入"查询物品 物品名"查看物品详情`;
+    return output.trim();
+  });
+  ctx.command("猫武士/战斗训练 <target:user>", "与指定用户的角色进行训练战斗（不消耗HP）").example("战斗训练 @火星").action(async ({ session }, target) => {
+    const channelId = session.channelId;
+    const userId = session.userId;
+    if (battleManager.isBattling(channelId)) {
+      return "请等待当前战斗结束！";
+    }
+    if (!target) {
+      return "请指定训练对手！正确格式：战斗训练 @用户名";
+    }
+    if (target === userId) {
+      return "不能和自己进行战斗训练哦！";
+    }
+    let player1 = await getOrCreateCharacter(userId);
+    const statusCheck = checkCharacterStatus(player1);
+    if (!statusCheck.canAct) {
+      return statusCheck.message;
+    }
+    let player2 = await getOrCreateCharacter(target);
+    const opponentStatusCheck = checkCharacterStatus(player2);
+    if (!opponentStatusCheck.canAct) {
+      return `对手目前状态不佳，无法进行战斗训练：${opponentStatusCheck.message}`;
+    }
+    if (!battleManager.startBattle(channelId, player1.currentHp, void 0)) {
+      return "战斗开始失败，请重试！";
+    }
+    const player1Char = {
+      name: player1.name,
+      constitution: player1.constitution,
+      attack: player1.attack,
+      toughness: player1.toughness,
+      crit: player1.crit,
+      agility: player1.agility,
+      hp: player1.currentHp,
+      // 使用当前HP
+      maxHp: player1.maxHp,
+      chargeTime: parseFloat((1 + 280 / (player1.agility + 70)).toFixed(2)),
+      nextAttackTime: 0
+    };
+    const player2Char = {
+      name: player2.name,
+      constitution: player2.constitution,
+      attack: player2.attack,
+      toughness: player2.toughness,
+      crit: player2.crit,
+      agility: player2.agility,
+      hp: player2.currentHp,
+      // 使用当前HP
+      maxHp: player2.maxHp,
+      chargeTime: parseFloat((1 + 280 / (player2.agility + 70)).toFixed(2)),
+      nextAttackTime: 0
+    };
+    const abortController = battleManager.getAbortController(channelId);
+    try {
+      await executeBattle(
+        session,
+        player1Char,
+        player2Char,
+        config.battleMessageInterval,
+        true,
+        // 是训练模式
+        abortController
+      );
+    } catch (error) {
+      if (error.name !== "AbortError") {
+        throw error;
+      }
+    } finally {
+      battleManager.endBattle(channelId);
+    }
+  });
+  setInterval(async () => {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const characters = await ctx.database.get("maple_warriors", {});
+      for (const character of characters) {
+        if (character.statusEndTime && now >= character.statusEndTime) {
+          const updates = {
+            status: "无",
+            previousStatus: "无",
+            statusEndTime: null,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          if (character.status === "睡眠" || character.status === "治疗") {
+            updates.currentHp = character.maxHp;
+          }
+          await ctx.database.set("maple_warriors", { id: character.id }, updates);
+        }
+      }
+    } catch (error) {
+      console.error("状态检查错误:", error);
+    }
+  }, 6e4);
+}
+__name(apply, "apply");
+async function executeBattle(session, player1, player2, battleMessageInterval, isTraining = false, abortController) {
+  const originalHp1 = player1.hp;
+  const originalHp2 = player2.hp;
+  const rates1 = calculateRates({
+    toughness: player1.toughness,
+    crit: player1.crit,
+    agility: player1.agility
+  });
+  const rates2 = calculateRates({
+    toughness: player2.toughness,
+    crit: player2.crit,
+    agility: player2.agility
+  });
+  const dodgeRate1 = parseFloat(rates1.dodgeRate);
+  const dodgeRate2 = parseFloat(rates2.dodgeRate);
+  const critRate1 = parseFloat(rates1.critRate);
+  const critRate2 = parseFloat(rates2.critRate);
+  player1.nextAttackTime = parseFloat(rates1.chargeTime);
+  player2.nextAttackTime = parseFloat(rates2.chargeTime);
+  let currentTime = 0;
+  const maxBattleTime = 180;
+  const battleType = isTraining ? "训练战斗" : "战斗";
+  await session.send(`${player1.name} vs ${player2.name}，${battleType}开始！`);
+  try {
+    while (currentTime <= maxBattleTime && player1.hp > 0 && player2.hp > 0) {
+      if (abortController?.signal.aborted) {
+        await session.send("战斗被强制结束！");
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, battleMessageInterval * 1e3));
+      let attacker;
+      let defender;
+      let attackTime = Math.min(player1.nextAttackTime, player2.nextAttackTime);
+      if (currentTime < attackTime) {
+        currentTime = attackTime;
+        continue;
+      }
+      if (Math.abs(player1.nextAttackTime - attackTime) < 0.01) {
+        attacker = player1;
+        defender = player2;
+        player1.nextAttackTime = currentTime + parseFloat(rates1.chargeTime);
+      } else {
+        attacker = player2;
+        defender = player1;
+        player2.nextAttackTime = currentTime + parseFloat(rates2.chargeTime);
+      }
+      let battleMessage = `${attacker.name}发动攻击！`;
+      const defenderDodgeRate = defender === player1 ? dodgeRate1 : dodgeRate2;
+      if (Math.random() < defenderDodgeRate) {
+        battleMessage += ` ${defender.name}闪避了！`;
+        await session.send(battleMessage);
+        currentTime = attackTime;
+        continue;
+      }
+      const baseDamage = attacker.attack * (0.5 + Math.random());
+      let initialDamage = Math.ceil(baseDamage);
+      let totalDamage = initialDamage;
+      const attackerCritRate = attacker === player1 ? critRate1 : critRate2;
+      let isCritical = false;
+      if (Math.random() < attackerCritRate) {
+        totalDamage *= 2;
+        isCritical = true;
+        battleMessage += ` 暴击！`;
+      }
+      const reduceAmount = defender.toughness * Math.random();
+      const reducedDamage = Math.min(Math.ceil(reduceAmount), totalDamage);
+      const finalDamage = totalDamage - reducedDamage;
+      if (finalDamage <= 0) {
+        if (isCritical) {
+          battleMessage += ` 造成了${totalDamage}点伤害。`;
+        }
+        battleMessage += ` 被${defender.name}抵挡住了！`;
+        await session.send(battleMessage);
+        currentTime = attackTime;
+        continue;
+      }
+      defender.hp -= finalDamage;
+      if (defender.hp < 0) defender.hp = 0;
+      if (isCritical) {
+        battleMessage += ` 造成了${totalDamage}点伤害。`;
+      } else {
+        battleMessage += ` 造成了${initialDamage}点伤害。`;
+      }
+      battleMessage += ` ${defender.name}抵挡了${reducedDamage}点伤害，实际造成${finalDamage}点伤害。${defender.name} HP: ${defender.hp}`;
+      await session.send(battleMessage);
+      if (defender.hp <= 0) {
+        await session.send(`战斗结束！${attacker.name} 胜利！`);
+        break;
+      }
+      currentTime = attackTime;
+    }
+    if (currentTime > maxBattleTime && player1.hp > 0 && player2.hp > 0) {
+      if (player1.hp > player2.hp) {
+        await session.send(`战斗超时！${player1.name} 剩余HP更高，获得胜利！`);
+      } else if (player2.hp > player1.hp) {
+        await session.send(`战斗超时！${player2.name} 剩余HP更高，获得胜利！`);
+      } else {
+        await session.send(`战斗超时！双方平局！`);
+      }
+    }
+  } catch (error) {
+    if (error.name !== "AbortError") {
+      throw error;
+    }
+  }
+}
+__name(executeBattle, "executeBattle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name,
+  using
+});

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "koishi-plugin-maple-warriors",
+  "description": "-",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "maple"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-maple-warriors
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-maple-warriors?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-maple-warriors)
+
+-