koishi-plugin-ggcevo-game 1.4.46 → 1.4.48

package/lib/index.js

@@ -1270,1142 +1270,6 @@ var bossPool = [
   }
 ];
 
-// src/boss/passive.ts
-var passiveConfig = {
-  "弱化形态": {
-    type: "伤害增减（负面）",
-    description: "子代防御脆弱，受到的伤害提高10%"
-  },
-  "异形甲壳": {
-    type: "伤害增减（正面）",
-    description: "受到的伤害降低20%"
-  },
-  "冰霜回复": {
-    type: "生存强化（生命回复）",
-    description: "生命值≤30%时，立即回复自身40%最大生命值，并为所有其他存活异形回复10%最大生命值（生效后移除）"
-  },
-  "冰霜进化": {
-    type: "状态免疫（寒冷伤害免疫）",
-    description: "免疫寒冷伤害，受到寒冷攻击时回复等量生命值"
-  },
-  "冰霜环绕": {
-    type: "生存强化（生命回复+群体增益）",
-    description: "生命值≤30%时，立即回复自身45%最大生命值，并使所有存活异形获得「寒霜地狱」技能（生效后移除）"
-  },
-  "寒霜地狱": {
-    type: "伤害增减（正面）",
-    description: "受到的伤害降低30%"
-  },
-  "应激甲壳I": {
-    type: "伤害增减（正面）",
-    description: "受到的伤害降低20%"
-  },
-  "应激甲壳II": {
-    type: "伤害增减（正面）",
-    description: "受到的伤害降低25%"
-  },
-  "求生本能I": {
-    type: "生存强化（生命回复）",
-    description: "濒死时立即回复自身30%最大生命值（生效后移除）"
-  },
-  "求生本能II": {
-    type: "生存强化（生命回复）",
-    description: "濒死时立即回复自身50%最大生命值（生效后移除）"
-  },
-  "冷适应": {
-    type: "状态免疫（寒冷伤害免疫）",
-    description: "累计承受10次寒冷伤害后，获得「惧热」标签并永久免疫寒冷伤害"
-  },
-  "感染空间站": {
-    type: "伤害增减（正面）",
-    description: "当空间站哨枪塔存活时，自身受到的伤害降低50%"
-  },
-  "病毒云": {
-    type: "伤害增减（正面）",
-    description: "受到的伤害降低10%"
-  },
-  "霉菌滋生": {
-    type: "生存强化（生命回复）",
-    description: "受击后，若空间站哨枪塔存活，为其回复1%最大生命值"
-  },
-  "岗哨机枪": {
-    type: "生存强化（生命回复）",
-    description: "每累计承受10次攻击，为所有其他存活异形回复10%最大生命值"
-  },
-  "结构装甲": {
-    type: "伤害增减（正面）",
-    description: "受实弹/能量武器伤害降低20%，受热能武器伤害降低40%"
-  },
-  "吸血唾液": {
-    type: "伤害增减（正面）",
-    description: "受击获得1层「吸血唾液」(上限20层)，每层使受到的伤害降低5%"
-  },
-  "进食": {
-    type: "生存强化（生命回复）",
-    description: "「吸血唾液」≥20层时，下次受击消耗所有层数并回复自身20%最大生命值"
-  },
-  "嗜血狂暴": {
-    type: "伤害增减（正面）",
-    description: "生命值≤50%时，受击额外获得1层「吸血唾液」且受到的伤害降低20%"
-  },
-  "吐血": {
-    type: "伤害增减（负面）",
-    description: "无「吸血唾液」层数时，受到的伤害提高20%"
-  },
-  "超导体": {
-    type: "状态转换（护盾→重甲）",
-    description: "生命值≤10%时，护盾标签永久转换为重甲标签"
-  },
-  "能量虹吸": {
-    type: "伤害增减（正面）",
-    description: "生命值≥70%时伤害降低40%，30%-70%时伤害降低20%"
-  },
-  "能源虹吸": {
-    type: "伤害增减（正面）",
-    description: "能量值≥80%时伤害降低50%，50%-80%时伤害降低30%"
-  },
-  "电能立场": {
-    type: "状态免疫（伤害免疫）",
-    description: "能量值≥30%时，55%概率免疫非热能伤害（每层寒冷降低5%触发概率）"
-  },
-  "电能冲击波": {
-    type: "生存强化（能量回复）",
-    description: "受击后回复100点能量"
-  },
-  "脉冲": {
-    type: "生存强化（生命回复）",
-    description: "能量值≥30%时，60%概率为所有存活异形回复100点生命（每层寒冷降低5%触发概率）"
-  },
-  "能量黑洞": {
-    type: "伤害增减（正面）",
-    description: "存在能量黑洞时，受到的伤害降低20%"
-  },
-  "火焰异形": {
-    type: "状态免疫（火焰伤害免疫）",
-    description: "免疫火焰伤害，受到火焰攻击时回复等量生命值"
-  },
-  "庞兽狂暴": {
-    type: "伤害增减（正面）",
-    description: "生命值≤50%时，受到的伤害降低50%"
-  },
-  "灼烧粘液": {
-    type: "生存强化（生命回复）",
-    description: "受击获得1层「灼烧粘液」；受火焰攻击时消耗所有层数并回复（层数×10）点生命"
-  },
-  "腐蚀胆汁": {
-    type: "生存强化（生命回复）",
-    description: "「灼烧粘液」≥10层时，下次受击消耗所有层数并为所有存活异形回复1000点生命"
-  },
-  "火焰吐息": {
-    type: "生存强化（生命回复）",
-    description: "「灼烧粘液」≥20层时，下次攻击消耗所有层数并为所有存活异形回复20%最大生命值"
-  },
-  "太阳耀斑": {
-    type: "状态移除+状态免疫（寒冷伤害免疫）",
-    description: "所有子代阵亡后，移除惧寒标签和孤立无援状态，并永久免疫寒冷伤害"
-  },
-  "燃烧潜地": {
-    type: "生存强化（生命回复）",
-    description: "生命值≤10%时立即回复50%最大生命值（生效后移除）"
-  },
-  "炼狱爆弹": {
-    type: "伤害增减（正面）",
-    description: "每层「灼烧粘液」使受到的伤害降低5%，存活子代存在时每层额外降低5%"
-  },
-  "猎手异形": {
-    type: "伤害增减（条件性）+状态免疫（火焰/寒冷伤害免疫）",
-    description: "存在其他存活异形时伤害降低20%，无其他存活异形时伤害提高20%；免疫火焰及寒冷伤害"
-  },
-  "狂暴": {
-    type: "伤害增减（正面）",
-    description: "生命值≤50%时，受到的伤害降低50%"
-  },
-  "伪装": {
-    type: "伤害增减（正面）",
-    description: "受击记录伤害来源武器名称，下次被同名武器攻击时伤害降低80%"
-  },
-  "致命一击": {
-    type: "状态免疫（伤害免疫）",
-    description: "受击时5%概率免疫该次伤害"
-  },
-  "星界之风": {
-    type: "生存强化（生命回复）",
-    description: "受击时5%概率为所有存活异形回复200点生命"
-  },
-  "心灵狂热": {
-    type: "伤害增减（正面）",
-    description: "生命值<50%时伤害降低20%且「星界之风」触发概率翻倍"
-  },
-  "宇宙能量": {
-    type: "生存强化（能量/生命回复）",
-    description: "受击回复等量能量值，能量溢出时转换为生命回复"
-  },
-  "复苏": {
-    type: "生存强化（生命/能量回复）",
-    description: "免疫致命伤害，回复60%最大生命与100%能量值，并获得「灵能构造炉」技能（生效后移除）"
-  },
-  "光影之刃": {
-    type: "状态叠加（层数叠加）",
-    description: "受击获得1层「光影之刃」(上限50层)"
-  },
-  "远古预兆": {
-    type: "状态免疫（伤害免疫）+状态增强（触发概率提升）",
-    description: "受击时1%概率免疫非热能伤害并回复100点能量，每层「光影之刃」使触发概率提升0.5%"
-  },
-  "超视距穿梭": {
-    type: "伤害增减（条件性）",
-    description: "能量≥60%时每层「光影之刃」使伤害降低10%，30%-60%时每层降低5%，能量≤10%时每层提高5%"
-  },
-  "灵能构造炉": {
-    type: "状态获得（技能获得）",
-    description: "受击时1%概率随机获得以下技能之一：天启超载护盾/塌缩脉冲/地毯式轰炸/轰炸引导"
-  },
-  "天启超载护盾": {
-    type: "生存强化（生命回复）",
-    description: "受击时10%概率触发，消耗当前「光影之刃」层数的一半（向下取整），并为所有存活异形回复（消耗层数×10）点生命"
-  },
-  "塌缩脉冲": {
-    type: "状态叠加（层数叠加）",
-    description: "受击后额外获得1层「光影之刃」"
-  },
-  "地毯式轰炸": {
-    type: "状态移除+伤害增减（正面）",
-    description: "移除孤立无援状态，受到的伤害降低80%"
-  },
-  "轰炸引导": {
-    type: "生存强化（能量回复）",
-    description: "受击时10%概率触发，消耗当前「光影之刃」层数的一半（向下取整），并回复（消耗层数×10）点能量"
-  }
-};
-
-// src/wish.ts
-var wishConfig = {
-  // 普通祈愿（总概率 5 * 19=95%）
-  common: [
-    {
-      name: "蚱蜢优购",
-      effect: "下一次购买武器(非传奇)享有20%的折扣"
-    },
-    {
-      name: "灵狐升运",
-      effect: "下一次升级武器享有20%的折扣"
-    },
-    {
-      name: "王权增幅",
-      effect: "攻击伤害+10%"
-    },
-    {
-      name: "金柚赐福",
-      effect: "立即获得250枚金币"
-    },
-    {
-      name: "夜市赠礼",
-      effect: "立即获得5枚咕咕币"
-    }
-  ],
-  // 稀有祈愿（总概率 5 * 1=5%）
-  rare: [
-    {
-      name: "悲鸣之锋",
-      effect: "攻击伤害+10% (武器等级0)，每级武器等级额外+10%"
-    },
-    {
-      name: "精灵双倍",
-      effect: "下一次击败主宰时可获得双倍的金币和咕咕币奖励"
-    },
-    {
-      name: "喵喵财源",
-      effect: "签到获得双倍的金币和咕咕币"
-    },
-    {
-      name: "暴击韵律",
-      effect: "攻击暴击率+20%"
-    },
-    {
-      name: "酥手空空",
-      effect: "立即失去50枚金币"
-    }
-  ]
-};
-
-// src/boss/damagecalculation.ts
-async function calculateTotalDamage(ctx, session, config, equippedWeapon, targetBoss, options) {
-  let effectMessage = [];
-  const finalTags = options?.customTags || targetBoss.tags || [];
-  const [profile] = await ctx.database.get("sc2arcade_player", { userId: session.userId });
-  const { regionId, realmId, profileId } = profile;
-  const handle = `${regionId}-S2-${realmId}-${profileId}`;
-  const weaponConfigEntry = Object.entries(weaponConfig).find(([_, c]) => c.id === equippedWeapon.weaponId);
-  const [weaponName, weaponData] = weaponConfigEntry;
-  const baseDamage = weaponData.damage * (1 + 0.1 * equippedWeapon.level);
-  const levelBonusPercent = (0.1 * equippedWeapon.level * 100).toFixed(0);
-  effectMessage.push(`🔫 ${weaponName}Lv.${equippedWeapon.level}：基础伤害+${levelBonusPercent}%`);
-  let totalAdditive = 0;
-  const tagAdditive = await calculateTagMultiplier(weaponData, finalTags, equippedWeapon);
-  totalAdditive += tagAdditive;
-  const { totalModAdd, hasCrit, modMessages } = calculateModifiers(
-    equippedWeapon,
-    weaponName,
-    await checkCritRhythm(ctx, handle)
-  );
-  totalAdditive += totalModAdd;
-  effectMessage.push(...modMessages);
-  const careerBonus = await calculateCareerAdditive(ctx, handle, weaponData.type, weaponData.id);
-  totalAdditive += careerBonus.value;
-  if (careerBonus.message) effectMessage.push(careerBonus.message);
-  const wishAdditive = await calculateWishAdditive(ctx, handle, equippedWeapon);
-  totalAdditive += wishAdditive.value;
-  if (wishAdditive.message) effectMessage.push(wishAdditive.message);
-  const [rankRecord] = await ctx.database.get("ggcevo_rank", { handle, rankseason: config.rankseason });
-  const rankAddResult = calculateRankAdditive(rankRecord);
-  totalAdditive += rankAddResult.value;
-  if (rankAddResult.message) {
-    effectMessage.push(rankAddResult.message);
-  }
-  let finalDamage = baseDamage * (1 + totalAdditive);
-  if (finalDamage < 1) {
-    finalDamage = 1;
-  }
-  return {
-    damage: Math.round(finalDamage),
-    hasCrit,
-    effectMessage
-  };
-}
-__name(calculateTotalDamage, "calculateTotalDamage");
-async function checkCritRhythm(ctx, handle) {
-  const [record] = await ctx.database.get("ggcevo_wish", {
-    handle,
-    wishname: "暴击韵律",
-    startTime: { $lte: /* @__PURE__ */ new Date() },
-    endTime: { $gte: /* @__PURE__ */ new Date() }
-  });
-  return !!record;
-}
-__name(checkCritRhythm, "checkCritRhythm");
-async function calculateTagMultiplier(weaponData, tags, equippedWeapon) {
-  const MOD_EFFECTS = [
-    { mod: "裂甲核心", tag: "重甲", value: 1.5 },
-    { mod: "助燃核心", tag: "惧热", value: 3 },
-    { mod: "助燃核心", tag: "生物", value: 2 },
-    { mod: "金刚石瞄准镜", tag: "重甲", value: 0.8 },
-    { mod: "护盾崩解核心", tag: "护盾", value: 0.8 }
-  ];
-  let totalAdditive = 0;
-  for (const tag of tags) {
-    const activeMod = MOD_EFFECTS.find(
-      (me) => me.tag === tag && equippedWeapon.installedMods?.includes(me.mod)
-    );
-    const effectValue = activeMod ? activeMod.value : weaponData.tagEffects?.[tag] ?? 1;
-    totalAdditive += effectValue - 1;
-  }
-  return totalAdditive;
-}
-__name(calculateTagMultiplier, "calculateTagMultiplier");
-function calculateModifiers(equippedWeapon, weaponName, hasCritRhythm) {
-  let totalModAdd = 0;
-  let hasCrit = false;
-  const modMessages = [];
-  let crystalCrit = 0;
-  let overloadCrit = 0;
-  let rhythmCrit = 0;
-  let weaponCrit = 0;
-  if (weaponName === "MK-4激光步枪") {
-    weaponCrit = 80;
-    modMessages.push(`🔫 【MK-4激光步枪】武器效果：暴击率+${weaponCrit}%`);
-  }
-  equippedWeapon.installedMods.forEach((mod) => {
-    if (mod === "动能增幅") {
-      totalModAdd += 0.2;
-      modMessages.push(`🛠️ 【动能增幅】生效：攻击伤害+20%`);
-    }
-    if (mod === "裂甲核心" && weaponName === modConfig[mod].exclusiveTo) {
-      totalModAdd += 0.4;
-      modMessages.push(`🛠️ 【裂甲核心】生效：攻击伤害+40%`);
-    }
-    if (mod === "棱镜水晶") {
-      crystalCrit = 20;
-      modMessages.push(`🛠️ 【棱镜水晶】生效：暴击率+20%`);
-    }
-    if (mod === "棱镜超载核心" && weaponName === modConfig[mod].exclusiveTo) {
-      overloadCrit = 80;
-      modMessages.push(`🛠️ 【棱镜超载核心】生效：暴击率+80%`);
-    }
-  });
-  rhythmCrit = hasCritRhythm ? 20 : 0;
-  if (hasCritRhythm) {
-    modMessages.push(`🎵 暴击韵律祈愿：暴击率+20%`);
-  }
-  const totalCritRate = Math.min(
-    crystalCrit + overloadCrit + rhythmCrit + weaponCrit,
-    // 包含武器专属暴击
-    100
-  );
-  if (totalCritRate > 0) {
-  }
-  if (totalCritRate > 0) {
-    const roll = Math.random() * 100;
-    if (roll <= totalCritRate) {
-      hasCrit = true;
-      totalModAdd += 1;
-    }
-  }
-  return {
-    totalModAdd,
-    hasCrit,
-    modMessages
-    // 返回模块消息数组
-  };
-}
-__name(calculateModifiers, "calculateModifiers");
-async function calculateCareerAdditive(ctx, handle, weaponType, weaponId) {
-  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-  let value = 0;
-  let message = "";
-  if (careerData?.career === "警卫长") {
-    value += 0.05;
-    message = "⚔️ 警卫长职业：攻击伤害+5%";
-  }
-  if (careerData?.career === "武器中士") {
-    value += 0.15;
-    message = "⚔️ 武器中士职业：攻击伤害+15%";
-  }
-  if (careerData?.career === "能量武器专家") {
-    if (weaponType === "能量武器") {
-      value += 0.2;
-      message = "⚔️ 能量武器专家职业：能量武器攻击伤害+20%";
-    }
-  }
-  if (careerData?.career === "纵火狂") {
-    if (weaponType === "热能武器") {
-      value += 0.2;
-      message = "⚔️ 纵火狂职业：热能武器攻击伤害+20%";
-    }
-  }
-  if (careerData?.career === "猩红杀手") {
-    if (weaponId === 7) {
-      value += 0.15;
-      message = "⚔️ 猩红杀手职业：侦察步枪攻击伤害+15%";
-    }
-  }
-  return { value, message };
-}
-__name(calculateCareerAdditive, "calculateCareerAdditive");
-async function calculateWishAdditive(ctx, handle, weapon) {
-  let value = 0;
-  const messages = [];
-  const [sovereign] = await ctx.database.get("ggcevo_wish", {
-    handle,
-    wishname: "王权增幅",
-    startTime: { $lte: /* @__PURE__ */ new Date() },
-    endTime: { $gte: /* @__PURE__ */ new Date() }
-  });
-  if (sovereign) {
-    value += 0.1;
-    messages.push("👑 王权增幅祈愿：攻击伤害+10%");
-  }
-  const [lament] = await ctx.database.get("ggcevo_wish", {
-    handle,
-    wishname: "悲鸣之锋",
-    startTime: { $lte: /* @__PURE__ */ new Date() },
-    endTime: { $gte: /* @__PURE__ */ new Date() }
-  });
-  if (lament) {
-    const levelBonus = 0.1 * (weapon.level + 1);
-    value += levelBonus;
-    messages.push(`🗡️ 悲鸣之锋祈愿：攻击伤害+${Math.round(levelBonus * 100)}%`);
-  }
-  const [critRhythm] = await ctx.database.get("ggcevo_wish", {
-    handle,
-    wishname: "暴击韵律",
-    startTime: { $lte: /* @__PURE__ */ new Date() },
-    endTime: { $gte: /* @__PURE__ */ new Date() }
-  });
-  if (critRhythm) {
-    messages.push("🎵 暴击韵律祈愿：攻击暴击率+20%");
-  }
-  return {
-    value,
-    message: messages.join("，")
-  };
-}
-__name(calculateWishAdditive, "calculateWishAdditive");
-function calculateRankAdditive(rankRecord) {
-  if (!rankRecord || rankRecord.rank <= 0) return { value: 0, message: "" };
-  const baseValue = Math.floor(rankRecord.rank / 300) * 0.01;
-  const cappedValue = Math.min(baseValue, 1);
-  if (cappedValue > 0) {
-    const percentage = Math.round(cappedValue * 100);
-    return {
-      value: cappedValue,
-      message: `🏆 胜点榜积分加成：攻击伤害+${percentage}%`
-    };
-  }
-  return { value: 0, message: "" };
-}
-__name(calculateRankAdditive, "calculateRankAdditive");
-
-// src/utils.ts
-async function gachaWithPity(ctx, handle) {
-  const [record] = await ctx.database.get("ggcevo_records", { handle });
-  const currentPity = record?.pityCounter ?? 0;
-  if (currentPity >= 89) {
-    await updatePityCounter(ctx, handle, true);
-    await ctx.database.upsert("ggcevo_records", [{
-      handle,
-      fullPityCount: (record?.fullPityCount || 0) + 1
-    }], ["handle"]);
-    return true;
-  }
-  const isWin = simpleDraw();
-  await updatePityCounter(ctx, handle, isWin);
-  return isWin;
-}
-__name(gachaWithPity, "gachaWithPity");
-async function gachaWithHiddenAward(ctx, handle) {
-  const backpackItems = await ctx.database.get("ggcevo_backpack", {
-    handle,
-    itemId: { $in: [2, 3] }
-  });
-  const itemMap = new Map(backpackItems.map((item) => [item.itemId, item]));
-  const isWin = HiddenAward();
-  if (isWin) {
-    const updates = [
-      {
-        itemId: 2,
-        addAmount: 1
-      },
-      {
-        itemId: 3,
-        addAmount: 1
-      }
-    ].map(({ itemId, addAmount }) => ({
-      handle,
-      itemId,
-      quantity: (itemMap.get(itemId)?.quantity || 0) + addAmount
-    }));
-    await ctx.database.upsert("ggcevo_backpack", updates, ["handle", "itemId"]);
-    const [record] = await ctx.database.get("ggcevo_records", { handle });
-    await ctx.database.upsert("ggcevo_records", [{
-      handle,
-      hiddenawards: (record?.hiddenawards || 0) + 1
-    }], ["handle"]);
-  }
-  return isWin;
-}
-__name(gachaWithHiddenAward, "gachaWithHiddenAward");
-async function updatePityCounter(ctx, handle, isWin) {
-  const [record] = await ctx.database.get("ggcevo_records", { handle });
-  const [backpack] = await ctx.database.get("ggcevo_backpack", { handle, itemId: 2 });
-  await ctx.database.upsert("ggcevo_records", [{
-    handle,
-    totalPulls: (record?.totalPulls || 0) + 1,
-    pityCounter: isWin ? 0 : (record?.pityCounter || 0) + 1
-  }], ["handle"]);
-  if (isWin) {
-    await ctx.database.upsert("ggcevo_backpack", [{
-      handle,
-      itemId: 2,
-      quantity: (backpack?.quantity || 0) + 1
-    }]);
-  }
-}
-__name(updatePityCounter, "updatePityCounter");
-async function checkSensitiveWord(ctx, content) {
-  try {
-    const response = await ctx.http("get", `https://v.api.aa1.cn/api/api-mgc/index.php?msg=${encodeURIComponent(content)}`);
-    return response.data.num !== "1";
-  } catch (error) {
-    console.error("敏感词查询失败:", error);
-    return false;
-  }
-}
-__name(checkSensitiveWord, "checkSensitiveWord");
-function simpleDraw() {
-  return Math.floor(Math.random() * 1e4) < 50;
-}
-__name(simpleDraw, "simpleDraw");
-function HiddenAward() {
-  return Math.floor(Math.random() * 1e4) < 1;
-}
-__name(HiddenAward, "HiddenAward");
-function getRandomInt(min, max) {
-  const actualMin = Math.min(min, max);
-  const actualMax = Math.max(min, max);
-  return Math.floor(Math.random() * (actualMax - actualMin + 1)) + actualMin;
-}
-__name(getRandomInt, "getRandomInt");
-function PetCapsuleToy() {
-  const num = Math.floor(Math.random() * 1e4);
-  if (num < 4e3) return "t3级宠物扭蛋";
-  if (num < 7e3) return "t2级宠物扭蛋";
-  if (num < 9e3) return "t1级宠物扭蛋";
-  return "t0级宠物扭蛋";
-}
-__name(PetCapsuleToy, "PetCapsuleToy");
-function isSameDate(a, b) {
-  return a.getUTCFullYear() === b.getUTCFullYear() && a.getUTCMonth() === b.getUTCMonth() && a.getUTCDate() === b.getUTCDate();
-}
-__name(isSameDate, "isSameDate");
-function isSameHalfDay(a, b) {
-  if (!isSameDate(a, b)) {
-    return false;
-  }
-  const hour1 = a.getUTCHours();
-  const hour2 = b.getUTCHours();
-  return hour1 < 12 && hour2 < 12 || hour1 >= 12 && hour2 >= 12;
-}
-__name(isSameHalfDay, "isSameHalfDay");
-function convertUTCtoChinaTime(input) {
-  const utcDate = new Date(input);
-  if (isNaN(utcDate.getTime())) {
-    throw new Error("Invalid date input");
-  }
-  const chinaTimestamp = utcDate.getTime() + 8 * 60 * 60 * 1e3;
-  return new Date(chinaTimestamp);
-}
-__name(convertUTCtoChinaTime, "convertUTCtoChinaTime");
-function formatDate(d) {
-  return d.toLocaleString("zh-CN", {
-    timeZone: "Asia/Shanghai",
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit"
-  });
-}
-__name(formatDate, "formatDate");
-function createHpBar(current, max) {
-  const ratio = current / max;
-  const filled = Math.floor(ratio * 20);
-  return "▰".repeat(filled) + "▱".repeat(20 - filled);
-}
-__name(createHpBar, "createHpBar");
-async function activateNextBossGroup(ctx, currentBossId = null) {
-  let availableIndices = [];
-  bossPool.forEach((bossGroup, index) => {
-    if (currentBossId === null || bossGroup.id !== currentBossId) {
-      availableIndices.push(index);
-    }
-  });
-  if (availableIndices.length === 0) {
-    availableIndices = Array.from({ length: bossPool.length }, (_, i) => i);
-  }
-  const randomIndex = availableIndices[Math.floor(Math.random() * availableIndices.length)];
-  const nextBossGroup = bossPool[randomIndex];
-  const mainBoss = await ctx.database.create("ggcevo_boss", {
-    name: nextBossGroup.main.name,
-    type: nextBossGroup.main.type,
-    HP: nextBossGroup.main.maxHP,
-    tags: nextBossGroup.main.tags,
-    // 新增标签字段
-    skills: [...nextBossGroup.main.passive],
-    energy: nextBossGroup.main.maxEnergy,
-    groupId: nextBossGroup.id,
-    isActive: true,
-    respawnTime: /* @__PURE__ */ new Date()
-  });
-  for (const minion of nextBossGroup.minions) {
-    await ctx.database.create("ggcevo_boss", {
-      name: minion.name,
-      type: minion.type,
-      HP: minion.maxHP,
-      tags: minion.tags,
-      // 新增标签字段
-      skills: [...minion.passive],
-      energy: minion.maxEnergy,
-      groupId: nextBossGroup.id,
-      isActive: true,
-      respawnTime: /* @__PURE__ */ new Date()
-    });
-  }
-  return mainBoss;
-}
-__name(activateNextBossGroup, "activateNextBossGroup");
-var weaponConfigById = {};
-for (const key in weaponConfig) {
-  weaponConfigById[weaponConfig[key].id] = weaponConfig[key];
-}
-async function calculateTotalPower(ctx, config, handle) {
-  const [rankData] = await ctx.database.get("ggcevo_rank", {
-    handle,
-    rankseason: config.rankseason
-  });
-  const baseRank = rankData?.rank || 0;
-  let total = baseRank;
-  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-  const career = careerData?.career;
-  if (career) {
-    if (career === "联盟新兵") total += 1e3;
-    else if (career === "辛迪加炮灰新兵") total += 2e3;
-    else if (["深空矿工", "医疗专家", "情报副官", "总工程师", "舰长", "机械化专家"].includes(career)) total += 2500;
-    else if (["清洁工", "辛迪加财务经理", "计算机专家", "指挥官", "装甲兵", "破坏者", "征募官"].includes(career)) total += 3e3;
-    else if (["警卫员下士", "警卫长", "武器中士"].includes(career)) total += 3500;
-    else if (["能量武器专家", "枪手", "猩红杀手", "纵火狂"].includes(career)) total += 4e3;
-  }
-  const weapons = await ctx.database.get("ggcevo_weapons", { handle });
-  for (const { weaponId, level, installedMods } of weapons) {
-    const weapon = weaponConfigById[weaponId];
-    if (!weapon) continue;
-    total += weapon.damage * 100;
-    total += level * (level + 1) / 2 * 1e3;
-    for (const modName of installedMods || []) {
-      const mod = modConfig[modName];
-      if (mod) {
-        if (mod.isExclusive) {
-          total += 4e3;
-        } else {
-          total += 2e3;
-        }
-      }
-    }
-  }
-  return total;
-}
-__name(calculateTotalPower, "calculateTotalPower");
-async function applyItemEffect(ctx, session, handle, itemConfig2, target) {
-  try {
-    const itemName = Object.entries(SyndicatedItems).find(
-      ([_, item]) => item.id === itemConfig2.id
-    )?.[0] || "未知物品";
-    if (itemConfig2.id === 1) {
-      const activeSentry = await ctx.database.get("ggcevo_boss", {
-        name: "空间站哨枪塔",
-        isActive: true
-      });
-      if (!activeSentry.length) return {
-        success: false,
-        message: "⚠️ 目标「空间站哨枪塔」未存活"
-      };
-      const [SentryTower] = await ctx.database.get("ggcevo_boss", {
-        name: "空间站哨枪塔",
-        isActive: true
-      });
-      const damageValue = SentryTower.HP;
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: "空间站哨枪塔" },
-        { isActive: false, HP: 0 }
-      );
-      await ctx.database.withTransaction(async () => {
-        const signRecords = await ctx.database.get("ggcevo_sign", { handle });
-        await ctx.database.upsert("ggcevo_sign", [{
-          handle,
-          totalRewards: (signRecords[0]?.totalRewards || 0) + damageValue
-        }], ["handle"]);
-        const [damageRecords] = await ctx.database.get("ggcevo_boss_damage", { handle });
-        await ctx.database.upsert("ggcevo_boss_damage", [{
-          handle,
-          playerName: session.username,
-          totalDamage: (damageRecords?.totalDamage || 0) + damageValue,
-          attackCount: damageRecords?.attackCount || 0,
-          bossGroupId: 4
-        }], ["handle"]);
-      });
-      return {
-        success: true,
-        message: `成功引爆${itemName}，对空间站哨枪塔造成${damageValue}点伤害，获得等额金币。`
-      };
-    }
-    if (itemConfig2.id === 2) {
-      if (!target) return {
-        success: false,
-        message: "您未选择合适的目标。"
-      };
-      const [targetboss] = await ctx.database.get("ggcevo_boss", {
-        name: target,
-        isActive: true
-      });
-      if (!targetboss) return {
-        success: false,
-        message: "无法找到指定的目标。"
-      };
-      if (targetboss.tags.includes("建筑") || targetboss.tags.includes("重型")) {
-        return {
-          success: false,
-          message: `目标${target}拥有"${targetboss.tags.includes("建筑") ? "建筑" : "重型"}"标签，无法使用此物品。`
-        };
-      }
-      const currentCount = targetboss?.skillStacks || 0;
-      if (currentCount <= 0) {
-        return {
-          success: false,
-          message: `目标${target}的技能层数已为0，无需使用此物品。`
-        };
-      }
-      const newCount = Math.max(0, currentCount - 10);
-      const reducedAmount = currentCount - newCount;
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: target },
-        { skillStacks: newCount }
-      );
-      return {
-        success: true,
-        message: `成功使用${itemName}，使${target}的技能层数减少10层`
-      };
-    }
-    if (itemConfig2.id === 4) {
-      if (!target) return {
-        success: false,
-        message: "您未选择合适的目标。"
-      };
-      const [targetboss] = await ctx.database.get("ggcevo_boss", {
-        name: target,
-        isActive: true
-      });
-      if (!targetboss || targetboss?.energy === 0) return {
-        success: false,
-        message: "您无法对没有能量的目标使用。"
-      };
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: target },
-        { energy: Math.max(targetboss.energy - 500, 0) }
-        // 确保不低于0
-      );
-      return {
-        success: true,
-        message: `成功使用${itemName}，消耗${target}500点能量`
-      };
-    }
-    return {
-      success: false,
-      message: `${itemName} 无法使用。`
-    };
-  } catch (error) {
-    console.error("物品效果处理失败:", error);
-    return {
-      success: false,
-      message: "⚠️ 物品效果处理异常，已回滚操作。"
-    };
-  }
-}
-__name(applyItemEffect, "applyItemEffect");
-async function handleTechUpgrade(ctx, handle, target) {
-  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-  if (!careerData || careerData.group !== "人类联盟") {
-    return "🚫 该功能需要【人类联盟】阵营权限";
-  }
-  const tech = Spacestationtechnology.find(
-    (t) => t.techname === target
-  );
-  const [techEntry] = await ctx.database.get("ggcevo_tech", { handle, techId: tech.techId });
-  const currentLevel = techEntry?.level || 0;
-  if (currentLevel >= tech.maxLevel) return `❌ ${tech.techname}已达最高等级`;
-  const nextLevel = currentLevel + 1;
-  const levelData = tech.levels.find((l) => l.level === nextLevel);
-  let originalCost = levelData.cost;
-  let actualCost = originalCost;
-  let discountApplied = false;
-  let discountDetails = [];
-  if (careerData.career === "情报副官") {
-    discountApplied = true;
-    actualCost = Math.floor(originalCost * 0.9);
-    discountDetails.push("🎖️ 情报副官职业：10%折扣");
-  }
-  const [signInfo] = await ctx.database.get("ggcevo_sign", { handle });
-  if (signInfo?.totalRewards < actualCost) {
-    const priceHint = discountApplied ? ` (原价${originalCost}金币)` : "";
-    return `❌ 金币不足！需要${actualCost}金币${priceHint}，您当前拥有：${signInfo?.totalRewards || 0}金币`;
-  }
-  let permissionGrantInfo = null;
-  if (tech.techname === "武器系统" && currentLevel === 4 && nextLevel === 5) {
-    permissionGrantInfo = {
-      type: "武器系统",
-      field: "legendarypermissions",
-      amount: 1,
-      message: "🎉 解锁传奇武器购买权限1次！"
-    };
-  }
-  if (tech.techname === "安防系统" && currentLevel === 4 && nextLevel === 5) {
-    permissionGrantInfo = {
-      type: "安防系统",
-      field: "explosiondoorauthority",
-      amount: 1,
-      message: "🔓 解锁安全军械库防爆门权限1次！"
-    };
-  }
-  await ctx.database.withTransaction(async () => {
-    await ctx.database.set("ggcevo_sign", { handle }, {
-      totalRewards: signInfo.totalRewards - actualCost
-    });
-    await ctx.database.upsert("ggcevo_tech", [{
-      handle,
-      techId: tech.techId,
-      level: nextLevel
-    }], ["handle", "techId"]);
-    if (permissionGrantInfo) {
-      const [permissionRecord] = await ctx.database.get("ggcevo_permissions", { handle });
-      const currentValue = permissionRecord?.[permissionGrantInfo.field] || 0;
-      await ctx.database.upsert("ggcevo_permissions", [{
-        handle,
-        [permissionGrantInfo.field]: currentValue + permissionGrantInfo.amount
-      }], ["handle"]);
-    }
-  });
-  let discountInfo = [];
-  if (discountApplied) {
-    discountInfo = [
-      "💰 折扣明细：",
-      ...discountDetails.map((detail) => `▸ ${detail}`)
-    ];
-  }
-  const costInfo = discountApplied ? `💸 花费金币：${actualCost} (原价${originalCost})` : `💸 花费金币：${actualCost}`;
-  let permissionMessage = [];
-  if (permissionGrantInfo) {
-    const [permissionRecord] = await ctx.database.get("ggcevo_permissions", { handle });
-    const newValue = permissionRecord?.[permissionGrantInfo.field] || permissionGrantInfo.amount;
-    permissionMessage.push(
-      permissionGrantInfo.message
-    );
-  }
-  return [
-    `✅ ${tech.techname} 升级至 Lv.${nextLevel}`,
-    costInfo,
-    ...discountInfo,
-    // 折扣信息
-    `📝 基础效果：${levelData.description}`,
-    `💼 职业效果：${levelData.careerBonus}`,
-    ...permissionMessage
-    // 权限解锁信息
-  ].filter(Boolean).join("\n");
-}
-__name(handleTechUpgrade, "handleTechUpgrade");
-async function handleWeaponUpgrade(ctx, handle, target) {
-  const weaponData = weaponConfig[target];
-  const [equipment] = await ctx.database.get("ggcevo_weapons", {
-    handle,
-    weaponId: weaponData.id
-  });
-  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-  if (!equipment) return "❌ 您尚未获得该武器";
-  const maxLevel = careerData?.career === "枪手" ? 7 : 6;
-  if (equipment.level >= maxLevel) return `❌ 该武器已达最高等级(Lv.${maxLevel})`;
-  const BASE_COST = [1050, 1450, 1850, 2250, 2650, 3050, 3450];
-  const baseCost = BASE_COST[equipment.level];
-  const weaponTechConfig = Spacestationtechnology.find((t) => t.techId === 2);
-  let techLevel = 0;
-  let totalDiscount = 0;
-  const discountDetails = [];
-  const isGunslinger = careerData?.career === "枪手";
-  if (isGunslinger) {
-    totalDiscount += 10;
-    discountDetails.push("🔫 枪手职业：10%折扣");
-  }
-  if (careerData?.group === "人类联盟") {
-    const [weaponTech] = await ctx.database.get("ggcevo_tech", { handle, techId: 2 }).catch(() => [{ level: 0 }]);
-    techLevel = Math.min(Math.max(weaponTech?.level || 0, 0), 5);
-    const isCareerMatch = weaponTechConfig?.careerNames.includes(careerData?.career);
-    const BASE_DISCOUNTS = [5, 10, 15, 20, 25];
-    const CAREER_DISCOUNTS = [10, 20, 30, 40, 50];
-    const baseDiscount = techLevel > 0 ? BASE_DISCOUNTS[techLevel - 1] : 0;
-    const careerDiscount = isCareerMatch && techLevel > 0 ? CAREER_DISCOUNTS[techLevel - 1] : 0;
-    const weaponDiscount = Math.max(baseDiscount, careerDiscount);
-    if (weaponDiscount > 0) {
-      totalDiscount += weaponDiscount;
-      discountDetails.push(
-        `⚙️ 武器系统Lv.${techLevel}：${weaponDiscount}%折扣`
-      );
-    }
-  }
-  const activeWish = await checkFoxBlessing(ctx, handle);
-  if (activeWish) {
-    totalDiscount += 20;
-    discountDetails.push("🦊 灵狐升运祈愿：20%折扣");
-  }
-  totalDiscount = Math.min(totalDiscount, 100);
-  const discountedCost = baseCost * (100 - totalDiscount) / 100;
-  const actualCost = Math.floor(discountedCost);
-  const [signInfo] = await ctx.database.get("ggcevo_sign", { handle });
-  if (signInfo?.totalRewards < actualCost) {
-    const priceInfo2 = totalDiscount > 0 ? `需要${actualCost}金币(原价${baseCost}金币)` : `需要${actualCost}金币`;
-    return `❌ ${priceInfo2}，您当前拥有：${signInfo?.totalRewards || 0}金币`;
-  }
-  const newLevel = equipment.level + 1;
-  const newModSlots = Math.floor(newLevel / 3) + 1;
-  await ctx.database.withTransaction(async () => {
-    await ctx.database.set("ggcevo_sign", { handle }, {
-      totalRewards: signInfo.totalRewards - actualCost
-    });
-    await ctx.database.set(
-      "ggcevo_weapons",
-      { handle, weaponId: weaponData.id },
-      {
-        level: newLevel,
-        modificationSlots: newModSlots
-      }
-    );
-    if (activeWish) {
-      await ctx.database.set(
-        "ggcevo_wish",
-        { id: activeWish.id },
-        { isused: true }
-      );
-    }
-  });
-  const damage = (weaponData.damage * (1 + 0.1 * newLevel)).toFixed(1);
-  let msg = `${target} 升级成功！Lv.${newLevel}`;
-  const priceInfo = totalDiscount > 0 ? `
-💸 花费：${actualCost}金币 (原价${baseCost}金币)` : `
-💸 花费：${actualCost}金币`;
-  msg += priceInfo;
-  if (discountDetails.length > 0) {
-    msg += `
-💰 折扣明细：
-▸ ${discountDetails.join("\n▸ ")}`;
-  }
-  msg += `
-💥 伤害：${damage}`;
-  msg += `
-🔧 改装槽：${newModSlots}个`;
-  return msg;
-}
-__name(handleWeaponUpgrade, "handleWeaponUpgrade");
-async function checkFoxBlessing(ctx, handle) {
-  return ctx.database.get("ggcevo_wish", {
-    handle,
-    wishname: "灵狐升运",
-    startTime: { $lte: /* @__PURE__ */ new Date() },
-    endTime: { $gte: /* @__PURE__ */ new Date() },
-    isused: false
-  }).then((records) => records[0]);
-}
-__name(checkFoxBlessing, "checkFoxBlessing");
-async function generateUpgradePriceList(ctx, handle) {
-  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-  const isGunslinger = careerData?.career === "枪手";
-  const isAlliance = careerData?.group === "人类联盟";
-  let techLevel = 0;
-  let techDiscountRate = 0;
-  let hasTechDiscount = false;
-  if (isAlliance) {
-    const [techData] = await ctx.database.get("ggcevo_tech", { handle, techId: 2 }).catch(() => [{ level: 0 }]);
-    const weaponTechConfig = Spacestationtechnology.find((t) => t.techId === 2);
-    techLevel = Math.min(techData?.level || 0, 5);
-    const isCareerMatch = weaponTechConfig?.careerNames.includes(careerData?.career);
-    const BASE_DISCOUNTS = [5, 10, 15, 20, 25];
-    const CAREER_DISCOUNTS = [10, 20, 30, 40, 50];
-    const baseDiscount = techLevel > 0 ? BASE_DISCOUNTS[techLevel - 1] : 0;
-    const careerDiscount = isCareerMatch ? CAREER_DISCOUNTS[techLevel - 1] : 0;
-    techDiscountRate = Math.max(baseDiscount, careerDiscount);
-    hasTechDiscount = techDiscountRate > 0;
-  }
-  const foxBlessing = await checkFoxBlessing(ctx, handle);
-  const foxDiscount = foxBlessing ? 20 : 0;
-  const hasFoxDiscount = foxDiscount > 0;
-  const gunslingerDiscount = isGunslinger ? 10 : 0;
-  const hasGunslingerDiscount = isGunslinger;
-  const BASE_COST = [1050, 1450, 1850, 2250, 2650, 3050, 3450];
-  const maxLevel = isGunslinger ? 7 : 6;
-  const priceDetails = [];
-  for (let i = 0; i < maxLevel; i++) {
-    const level = `${i}→${i + 1}`;
-    let baseCost = BASE_COST[i];
-    let finalPrice = baseCost;
-    let discountsApplied = [];
-    let totalDiscount = 0;
-    if (isGunslinger) {
-      totalDiscount += gunslingerDiscount;
-      discountsApplied.push(`${gunslingerDiscount}% (枪手)`);
-    }
-    if (isAlliance && hasTechDiscount) {
-      totalDiscount += techDiscountRate;
-      discountsApplied.push(`${techDiscountRate}% (科技)`);
-    }
-    if (hasFoxDiscount) {
-      totalDiscount += foxDiscount;
-      discountsApplied.push(`${foxDiscount}% (灵狐)`);
-    }
-    if (totalDiscount > 0) {
-      totalDiscount = Math.min(totalDiscount, 100);
-      finalPrice = Math.floor(baseCost * (100 - totalDiscount) / 100);
-    }
-    const showOriginal = finalPrice < baseCost;
-    const levelInfo = `等级 ${level.padEnd(5)}`;
-    const priceInfo = `▸ 价格: ${finalPrice.toString().padStart(4)}${showOriginal ? ` (原价${baseCost})` : ""}`;
-    let discountDetail = "";
-    if (discountsApplied.length > 0) {
-      discountDetail = ` - 折扣总计: ${totalDiscount}% [${discountsApplied.join(", ")}]`;
-    }
-    priceDetails.push(`${levelInfo}
-${priceInfo}`);
-  }
-  const discountNotice = [];
-  if (hasTechDiscount || hasFoxDiscount || hasGunslingerDiscount) {
-    discountNotice.push("💰 当前折扣：");
-  }
-  if (isGunslinger) {
-    discountNotice.push(`▸ 🔫 枪手职业：10%折扣`);
-  }
-  if (isAlliance && hasTechDiscount) {
-    discountNotice.push(`▸ ⚙️ 武器系统Lv.${techLevel}：${techDiscountRate}%折扣`);
-  }
-  if (hasFoxDiscount) {
-    discountNotice.push(`▸ 🦊 灵狐升运祈愿：20%折扣`);
-  }
-  if (!hasTechDiscount && !hasFoxDiscount && !hasGunslingerDiscount) {
-    if (isAlliance) {
-      discountNotice.push("💡 提示：升级武器系统科技可获得折扣");
-    } else if (careerData?.group === "辛迪加海盗") {
-      discountNotice.push("💡 提示：转职为枪手职业可获得折扣");
-    } else {
-      discountNotice.push("💡 提示：加入人类联盟或辛迪加海盗可获得折扣");
-    }
-  }
-  if (isGunslinger) {
-    discountNotice.push("▸ 🔝 枪手职业：武器等级上限提升至7级");
-  }
-  return [
-    "⚡ 武器升级价格表 ⚡",
-    `武器等级上限: ${maxLevel}级${isGunslinger ? " (枪手职业)" : ""}`,
-    "使用「升级 武器名称」对武器进行等级升级",
-    ...discountNotice,
-    "====================",
-    ...priceDetails,
-    "===================="
-  ].join("\n");
-}
-__name(generateUpgradePriceList, "generateUpgradePriceList");
-async function getRankInfo(ctx, config, handle) {
-  const [user] = await ctx.database.get("ggcevo_rank", {
-    handle,
-    rankseason: config.rankseason
-  });
-  if (!user) return "暂未找到排名信息。";
-  if (user.Blacklist) return "❌ 该用户已被禁止参加本赛季胜点榜。";
-  const allRanks = await ctx.database.select("ggcevo_rank").where({ Blacklist: false, rankseason: config.rankseason }).orderBy("rank", "desc").execute();
-  const userRank = allRanks.findIndex((u) => u.handle === handle) + 1;
-  const isSafe = await checkSensitiveWord(ctx, user.name);
-  const displayName = isSafe ? user.name : (user.name[0] || "") + "***";
-  return `🎮 咕咕排名信息 🎮
-------------------------------
-昵称：${displayName}
-句柄：${user.handle}
-当前积分：${user.rank}
-参赛次数：${user.matches} 次
-胜率：${user.matches === 0 ? "0.00%" : (user.wins / user.matches * 100).toFixed(2) + "%"}
-全服排名：第 ${userRank} 名
-------------------------------`;
-}
-__name(getRankInfo, "getRankInfo");
-function isWithinProtection(protections) {
-  const now = /* @__PURE__ */ new Date();
-  return protections.some(
-    (p) => p.status === "active" && now >= p.startTime && now <= p.endTime
-  );
-}
-__name(isWithinProtection, "isWithinProtection");
-function formatTime(date) {
-  return date.toLocaleString("zh-CN", {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  });
-}
-__name(formatTime, "formatTime");
-
 // src/boss/BattleEffectProcessor.ts
 var battleStatsMap = {};
 function updateStatsByName(name2, updates) {
@@ -2445,6 +1309,9 @@ function updateStatsByName(name2, updates) {
 }
 __name(updateStatsByName, "updateStatsByName");
 function getMaxHPByName(bossName) {
+  if (bossName === "测试假人") {
+    return 1e6;
+  }
   for (const boss of bossPool) {
     if (boss.main.name === bossName) {
       return boss.main.maxHP;
@@ -2459,6 +1326,9 @@ function getMaxHPByName(bossName) {
 }
 __name(getMaxHPByName, "getMaxHPByName");
 function getMaxEnergyByName(bossName) {
+  if (bossName === "测试假人") {
+    return 1e3;
+  }
   for (const boss of bossPool) {
     if (boss.main.name === bossName) {
       return boss.main.maxEnergy;
@@ -2499,7 +1369,7 @@ var BattleEffectProcessor = {
   }, "handleAlienShell"),
   // 孤立无援处理（活跃Boss中仅自己时增伤20%）
   handleIsolated: /* @__PURE__ */ __name(function(targetBoss, activeBosses, tempMark) {
-    if (tempMark) {
+    if (tempMark || targetBoss.name === "测试假人") {
       return null;
     }
     const isIsolated = activeBosses.length === 1 && // 活跃Boss仅1个
@@ -2516,13 +1386,13 @@ var BattleEffectProcessor = {
     }
     return null;
   }, "handleIsolated"),
-  handleFrostRegeneration: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+  handleFrostRegeneration: /* @__PURE__ */ __name(function(targetBoss, activeBosses, maxStatsMap) {
     const messages = [];
     const otherUpdates = [];
     if (!targetBoss.skills.includes("冰霜回复")) {
       return null;
     }
-    const targetMaxHP = getMaxHPByName(targetBoss.name);
+    const targetMaxHP = maxStatsMap[targetBoss.name].maxHP;
     const currentHP = targetBoss.HP;
     if (currentHP > targetMaxHP * 0.3) {
       return null;
@@ -2540,7 +1410,7 @@ var BattleEffectProcessor = {
     );
     otherSurvivingBosses.forEach((otherBoss) => {
       const otherName = otherBoss.name;
-      const otherMaxHP = getMaxHPByName(otherName);
+      const otherMaxHP = maxStatsMap[otherBoss.name].maxHP;
       const otherHealAmount = Math.round(otherMaxHP * 0.1);
       otherUpdates.push({
         name: otherName,
@@ -3476,807 +2346,1954 @@ var BattleEffectProcessor = {
       messages.push(`🎭 【伪装】生效：记录新武器「${weaponName}」`);
     }
     return {
-      nerfMultiplier,
+      nerfMultiplier,
+      messages,
+      targetUpdates
+    };
+  }, "handleDisguise"),
+  // 致命一击处理（概率免疫伤害）
+  handleDeadlyHit: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let isImmune = false;
+    if (!targetBoss.skills.includes("致命一击")) {
+      return null;
+    }
+    if (Math.random() < 0.05) {
+      isImmune = true;
+      messages.push(`💀 【致命一击】生效：5%概率免疫伤害`);
+    }
+    return { isImmune, messages };
+  }, "handleDeadlyHit"),
+  /** 星界之风处理（概率群体回复）- 修正版 */
+  handleAstralWind: /* @__PURE__ */ __name(function(targetBoss, activeBosses, doubleChance) {
+    const messages = [];
+    const otherUpdates = [];
+    const baseHealAmount = 200;
+    if (!targetBoss.skills.includes("星界之风")) {
+      return null;
+    }
+    const triggerProbability = doubleChance ? 0.1 : 0.05;
+    if (Math.random() >= triggerProbability) {
+      return null;
+    }
+    const survivingBosses = activeBosses.filter((boss) => boss.isActive);
+    survivingBosses.forEach((boss) => {
+      const bossName = boss.name;
+      if (baseHealAmount > 0) {
+        otherUpdates.push({
+          name: bossName,
+          updates: { hpChange: baseHealAmount }
+        });
+      }
+      messages.push(`🌬️ 【星界之风】触发：为「${bossName}」回复${baseHealAmount}点生命值`);
+    });
+    return {
+      messages,
+      otherUpdates
+    };
+  }, "handleAstralWind"),
+  /** 心灵狂热处理（低生命减伤和概率强化）- 修正版 */
+  handleMindFrenzy: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    let doubleAstralWind = false;
+    if (!targetBoss.skills.includes("心灵狂热")) {
+      return null;
+    }
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const hpPercent = targetBoss.HP / maxHP;
+    if (hpPercent <= 0.5) {
+      nerfMultiplier = 0.2;
+      doubleAstralWind = true;
+      messages.push(`🧠 【心灵狂热】生效：生命值≤50%，受到的伤害-20%，「星界之风」触发概率翻倍`);
+    }
+    return { nerfMultiplier, doubleAstralWind, messages };
+  }, "handleMindFrenzy"),
+  //宇宙能量
+  handleCosmicEnergy: /* @__PURE__ */ __name(function(targetBoss, damage) {
+    if (!targetBoss.skills.includes("宇宙能量")) {
+      return null;
+    }
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const currentEnergy = targetBoss.energy || 0;
+    const energyToAdd = damage;
+    if (energyToAdd <= 0) {
+      return null;
+    }
+    let energyGained = 0;
+    let overflowHeal = 0;
+    if (currentEnergy + energyToAdd <= maxEnergy) {
+      energyGained = energyToAdd;
+    } else {
+      energyGained = maxEnergy - currentEnergy;
+      overflowHeal = currentEnergy + energyToAdd - maxEnergy;
+    }
+    if (energyGained <= 0 && overflowHeal <= 0) {
+      return null;
+    }
+    const messages = [];
+    const updates = {};
+    let messageParts = [];
+    if (energyGained > 0) {
+      messageParts.push(`获得${energyGained}点能量`);
+      updates.energyChange = energyGained;
+    }
+    if (overflowHeal > 0) {
+      messageParts.push(`${overflowHeal}点溢出伤害转为生命回复`);
+      updates.hpChange = overflowHeal;
+    }
+    if (messageParts.length > 0) {
+      messages.push(`🌌 【宇宙能量】生效：${messageParts.join("，")}`);
+    }
+    return {
+      messages,
+      targetUpdates: {
+        name: targetBoss.name,
+        updates
+      }
+    };
+  }, "handleCosmicEnergy"),
+  // 复苏 (修改后)
+  handleRevival: /* @__PURE__ */ __name(function(targetBoss, damageAmount) {
+    const messages = [];
+    if (!targetBoss.skills.includes("复苏")) {
+      return null;
+    }
+    const isLethal = damageAmount >= targetBoss.HP;
+    if (!isLethal) {
+      return null;
+    }
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const healAmount = Math.round(maxHP * 0.6);
+    const energyGain = maxEnergy;
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        hpChange: healAmount,
+        // 回复60%最大生命值
+        energyChange: energyGain,
+        // 回复100%能量
+        skillsRemoved: ["复苏"],
+        // 移除复苏技能
+        skillsAdded: ["灵能构造炉"]
+        // 添加新技能
+      }
+    };
+    messages.push(`🔥 【复苏】生效：承受致命伤害时免疫死亡，回复${healAmount}点生命值和${energyGain}点能量，获得「灵能构造炉」技能`);
+    messages.push(`🔥 【复苏】技能移除`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleRevival"),
+  /** 光影之刃处理（层数叠加） */
+  handleBladeOfLight: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    const maxStacks = 50;
+    if (!targetBoss.skills.includes("光影之刃")) {
+      return null;
+    }
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks >= maxStacks) {
+      return null;
+    }
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: 1
+      }
+    };
+    const newStacks = currentStacks + 1;
+    messages.push(`✨ 【光影之刃】生效：获得1层「光影之刃」`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleBladeOfLight"),
+  /** 远古预兆处理（概率免疫能量伤害）- 增加boost参数 */
+  handleAncientOmen: /* @__PURE__ */ __name(function(targetBoss, weaponData) {
+    const messages = [];
+    let isImmune = false;
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("远古预兆")) {
+      return null;
+    }
+    if (weaponData.type === "热能武器") {
+      return null;
+    }
+    const lightBladeStacks = targetBoss.skillStacks || 0;
+    const boostPerStack = 5e-3;
+    const totalBoost = lightBladeStacks * boostPerStack;
+    const baseProbability = 0.01;
+    const actualProbability = Math.min(baseProbability + totalBoost, 1);
+    if (Math.random() >= actualProbability) {
+      return null;
+    }
+    isImmune = true;
+    const energyGained = 100;
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        energyChange: energyGained
+        // 回复100点能量
+      }
+    };
+    messages.push(`🔮 【远古预兆】触发：${(actualProbability * 100).toFixed(2)}%概率免疫非热能武器伤害，并回复${energyGained}点能量`);
+    return {
+      isImmune,
+      messages,
+      targetUpdates
+    };
+  }, "handleAncientOmen"),
+  /** 超视距穿梭处理（层数相关伤害调整） */
+  handleHyperRangeShift: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    let buffMultiplier = 0;
+    if (!targetBoss.skills.includes("超视距穿梭")) {
+      return null;
+    }
+    const currentEnergy = targetBoss.energy || 0;
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const energyPercent = currentEnergy / maxEnergy;
+    if (energyPercent >= 0.6) {
+      nerfMultiplier = targetBoss.skillStacks * 0.1;
+      messages.push(`🚀 【超视距穿梭】生效：能量值≥60%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
+    } else if (energyPercent >= 0.3) {
+      nerfMultiplier = targetBoss.skillStacks * 0.05;
+      messages.push(`🚀 【超视距穿梭】生效：能量值≥30%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
+    } else if (energyPercent <= 0.1) {
+      buffMultiplier = targetBoss.skillStacks * 0.05;
+      messages.push(`🚀 【超视距穿梭】生效：能量值≤10%，受到的伤害+${(buffMultiplier * 100).toFixed(0)}%`);
+    }
+    return { nerfMultiplier, buffMultiplier, messages };
+  }, "handleHyperRangeShift"),
+  /** 灵能构造炉处理（随机获得技能）- 增加boost参数 */
+  handlePsychicForge: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let newSkill = null;
+    let targetUpdates = null;
+    const possibleSkills = [
+      "天启超载护盾",
+      "塌缩脉冲",
+      "地毯式轰炸",
+      "轰炸引导"
+    ];
+    if (!targetBoss.skills.includes("灵能构造炉")) {
+      return null;
+    }
+    const baseProbability = 0.05;
+    if (Math.random() >= baseProbability) {
+      return null;
+    }
+    const availableSkills = possibleSkills.filter(
+      (skill) => !targetBoss.skills.includes(skill)
+    );
+    if (availableSkills.length === 0) {
+      return null;
+    }
+    newSkill = availableSkills[Math.floor(Math.random() * availableSkills.length)];
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillsAdded: [newSkill]
+      }
+    };
+    messages.push(`⚙️ 【灵能构造炉】触发：${(baseProbability * 100).toFixed(2)}%概率获得新技能「${newSkill}」`);
+    return {
       messages,
+      newSkill,
       targetUpdates
     };
-  }, "handleDisguise"),
-  // 致命一击处理（概率免疫伤害）
-  handleDeadlyHit: /* @__PURE__ */ __name(function(targetBoss) {
+  }, "handlePsychicForge"),
+  // 修改后的天启超载护盾处理函数
+  handleOverdriveShield: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
     const messages = [];
-    let isImmune = false;
-    if (!targetBoss.skills.includes("致命一击")) {
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("天启超载护盾")) {
       return null;
     }
-    if (Math.random() < 0.05) {
-      isImmune = true;
-      messages.push(`💀 【致命一击】生效：5%概率免疫伤害`);
-    }
-    return { isImmune, messages };
-  }, "handleDeadlyHit"),
-  /** 星界之风处理（概率群体回复）- 修正版 */
-  handleAstralWind: /* @__PURE__ */ __name(function(targetBoss, activeBosses, doubleChance) {
-    const messages = [];
-    const otherUpdates = [];
-    const baseHealAmount = 200;
-    if (!targetBoss.skills.includes("星界之风")) {
+    if (Math.random() >= 0.1) {
       return null;
     }
-    const triggerProbability = doubleChance ? 0.1 : 0.05;
-    if (Math.random() >= triggerProbability) {
+    const currentStacks = targetBoss.skillStacks || 0;
+    const consumedStacks = Math.floor(currentStacks / 2);
+    if (consumedStacks <= 0) {
       return null;
     }
     const survivingBosses = activeBosses.filter((boss) => boss.isActive);
+    messages.push(`🛡️ 【天启超载护盾】触发：消耗${consumedStacks}层「光影之刃」`);
     survivingBosses.forEach((boss) => {
-      const bossName = boss.name;
-      if (baseHealAmount > 0) {
-        otherUpdates.push({
-          name: bossName,
-          updates: { hpChange: baseHealAmount }
-        });
-      }
-      messages.push(`🌬️ 【星界之风】触发：为「${bossName}」回复${baseHealAmount}点生命值`);
+      const healAmount = consumedStacks * 10;
+      otherUpdates.push({
+        name: boss.name,
+        updates: { hpChange: healAmount }
+      });
+      messages.push(`为「${boss.name}」回复${healAmount}点生命值`);
     });
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -consumedStacks
+        // 消耗层数
+      }
+    };
     return {
       messages,
+      targetUpdates,
       otherUpdates
     };
-  }, "handleAstralWind"),
-  /** 心灵狂热处理（低生命减伤和概率强化）- 修正版 */
-  handleMindFrenzy: /* @__PURE__ */ __name(function(targetBoss) {
+  }, "handleOverdriveShield"),
+  /** 塌缩脉冲处理（额外叠加层数） */
+  handleCollapsingPulse: /* @__PURE__ */ __name(function(targetBoss) {
     const messages = [];
-    let nerfMultiplier = 0;
-    let doubleAstralWind = false;
-    if (!targetBoss.skills.includes("心灵狂热")) {
+    let targetUpdates = null;
+    const maxStacks = 49;
+    if (!targetBoss.skills.includes("塌缩脉冲")) {
       return null;
     }
-    const maxHP = getMaxHPByName(targetBoss.name);
-    const hpPercent = targetBoss.HP / maxHP;
-    if (hpPercent <= 0.5) {
-      nerfMultiplier = 0.2;
-      doubleAstralWind = true;
-      messages.push(`🧠 【心灵狂热】生效：生命值≤50%，受到的伤害-20%，「星界之风」触发概率翻倍`);
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks >= maxStacks) {
+      return null;
     }
-    return { nerfMultiplier, doubleAstralWind, messages };
-  }, "handleMindFrenzy"),
-  //宇宙能量
-  handleCosmicEnergy: /* @__PURE__ */ __name(function(targetBoss, damage) {
-    if (!targetBoss.skills.includes("宇宙能量")) {
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: 1
+      }
+    };
+    const newStacks = currentStacks + 1;
+    messages.push(`🌀 【塌缩脉冲】生效：额外获得1层「光影之刃」`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleCollapsingPulse"),
+  /** 地毯式轰炸处理 */
+  handleCarpetBombing: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    if (!targetBoss.skills.includes("地毯式轰炸")) {
       return null;
     }
-    const maxEnergy = getMaxEnergyByName(targetBoss.name);
-    const currentEnergy = targetBoss.energy || 0;
-    const energyToAdd = damage;
-    if (energyToAdd <= 0) {
+    nerfMultiplier = 0.8;
+    messages.push(`💣 【地毯式轰炸】生效：受到的伤害-80%`);
+    return { nerfMultiplier, messages, tempMark: true };
+  }, "handleCarpetBombing"),
+  // 修改后的轰炸引导处理函数
+  handleBombardmentGuide: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("轰炸引导")) {
       return null;
     }
-    let energyGained = 0;
-    let overflowHeal = 0;
-    if (currentEnergy + energyToAdd <= maxEnergy) {
-      energyGained = energyToAdd;
-    } else {
-      energyGained = maxEnergy - currentEnergy;
-      overflowHeal = currentEnergy + energyToAdd - maxEnergy;
+    if (Math.random() >= 0.1) {
+      return null;
     }
-    if (energyGained <= 0 && overflowHeal <= 0) {
+    const currentStacks = targetBoss.skillStacks || 0;
+    const consumedStacks = Math.floor(currentStacks / 2);
+    if (consumedStacks <= 0) {
       return null;
     }
+    const energyGained = consumedStacks * 10;
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -consumedStacks,
+        // 消耗层数
+        energyChange: energyGained
+        // 回复能量
+      }
+    };
+    messages.push(`🎯 【轰炸引导】触发：消耗${consumedStacks}层「光影之刃」，获得${energyGained}点能量`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleBombardmentGuide"),
+  // 统一的辐射效果处理函数
+  handleRadiationEffect: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
     const messages = [];
-    const updates = {};
-    let messageParts = [];
-    if (energyGained > 0) {
-      messageParts.push(`获得${energyGained}点能量`);
-      updates.energyChange = energyGained;
+    let layerAdded = false;
+    const currentLayers = targetBoss.radiationLayers || 0;
+    const effectiveLayers = Math.min(currentLayers, 20);
+    const buffMultiplier = effectiveLayers * 0.025;
+    if (effectiveLayers > 0) {
+      messages.push(`☢️ 【辐射增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
+      if (currentLayers > 20) {
+      }
     }
-    if (overflowHeal > 0) {
-      messageParts.push(`${overflowHeal}点溢出伤害转为生命回复`);
-      updates.hpChange = overflowHeal;
+    let targetUpdates = null;
+    if (weaponName === "伽马枪" && // 使用伽马枪
+    !targetBoss.tags.includes("机械") && // 非机械目标
+    targetBoss.tags.includes("生物")) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          radiationLayersChange: 1
+          // 辐射层数增加1
+        }
+      };
+      const newLayers = currentLayers + 1;
+      messages.push(`☢️ 【伽马枪】武器效果：获得1层「辐射」`);
+      layerAdded = true;
     }
-    if (messageParts.length > 0) {
-      messages.push(`🌌 【宇宙能量】生效：${messageParts.join("，")}`);
+    return {
+      messages,
+      targetUpdates,
+      buffMultiplier,
+      layerAdded
+      // 返回层数增加标记
+    };
+  }, "handleRadiationEffect"),
+  // 统一的寒冷效果处理函数
+  handleColdEffect: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
+    const messages = [];
+    let layerAdded = false;
+    const currentLayers = targetBoss.coldLayers || 0;
+    const effectiveLayers = Math.min(currentLayers, 20);
+    const buffMultiplier = effectiveLayers * 0.025;
+    if (effectiveLayers > 0) {
+      messages.push(`❄️ 【寒冷增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
+      if (currentLayers > 20) {
+      }
+    }
+    let targetUpdates = null;
+    if (weaponName === "零度之下") {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          coldLayersChange: 1
+          // 寒冷层数增加1
+        }
+      };
+      const newLayers = currentLayers + 1;
+      messages.push(`❄️【零度之下】武器效果： 获得1层「寒冷」`);
+      layerAdded = true;
+    }
+    return {
+      messages,
+      targetUpdates,
+      buffMultiplier,
+      layerAdded
+      // 返回层数增加标记
+    };
+  }, "handleColdEffect"),
+  // 统一的武器能量消耗处理函数
+  handleWeaponEnergyDrain: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
+    const weaponEnergyDrain = {
+      "弧焊枪": 200,
+      "DG-3电弧步枪": 500
+    };
+    const drainValue = weaponEnergyDrain[weaponName];
+    if (!drainValue) {
+      return null;
+    }
+    const messages = [];
+    const success = drainValue > 0;
+    let targetUpdates = null;
+    if (success) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          energyChange: -drainValue
+          // 消耗能量（负值）
+        }
+      };
+    }
+    const weaponDisplayName = weaponName === "弧焊枪" ? "弧焊枪" : "DG-3电弧步枪";
+    if (success) {
+      messages.push(`⚡ 【${weaponDisplayName}】武器效果：消耗${drainValue}点能量`);
     }
     return {
       messages,
-      targetUpdates: {
-        name: targetBoss.name,
-        updates
-      }
+      targetUpdates,
+      success
     };
-  }, "handleCosmicEnergy"),
-  // 复苏 (修改后)
-  handleRevival: /* @__PURE__ */ __name(function(targetBoss, damageAmount) {
-    const messages = [];
-    if (!targetBoss.skills.includes("复苏")) {
-      return null;
-    }
-    const isLethal = damageAmount >= targetBoss.HP;
-    if (!isLethal) {
+  }, "handleWeaponEnergyDrain"),
+  // 统一的武器层数减少处理函数
+  handleWeaponLayerReduction: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
+    const weaponLayerReduction = {
+      "脉冲扰乱枪": 2
+      // 可以在这里添加其他武器及其减少层数
+    };
+    const reductionAmount = weaponLayerReduction[weaponName];
+    if (!reductionAmount) {
       return null;
     }
-    const maxHP = getMaxHPByName(targetBoss.name);
-    const maxEnergy = getMaxEnergyByName(targetBoss.name);
-    const healAmount = Math.round(maxHP * 0.6);
-    const energyGain = maxEnergy;
-    const targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        hpChange: healAmount,
-        // 回复60%最大生命值
-        energyChange: energyGain,
-        // 回复100%能量
-        skillsRemoved: ["复苏"],
-        // 移除复苏技能
-        skillsAdded: ["灵能构造炉"]
-        // 添加新技能
-      }
-    };
-    messages.push(`🔥 【复苏】生效：承受致命伤害时免疫死亡，回复${healAmount}点生命值和${energyGain}点能量，获得「灵能构造炉」技能`);
-    messages.push(`🔥 【复苏】技能移除`);
-    return {
-      messages,
-      targetUpdates
-    };
-  }, "handleRevival"),
-  /** 光影之刃处理（层数叠加） */
-  handleBladeOfLight: /* @__PURE__ */ __name(function(targetBoss) {
     const messages = [];
+    const reductionSuccess = reductionAmount > 0;
     let targetUpdates = null;
-    const maxStacks = 50;
-    if (!targetBoss.skills.includes("光影之刃")) {
-      return null;
+    if (reductionSuccess) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          skillStacksChanged: -reductionAmount
+          // 减少层数
+        }
+      };
     }
-    const currentStacks = targetBoss.skillStacks || 0;
-    if (currentStacks >= maxStacks) {
-      return null;
+    if (reductionSuccess) {
+      messages.push(`⚡ 【${weaponName}】武器效果：技能层数减少${reductionAmount}层`);
     }
-    targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        skillStacksChanged: 1
-      }
-    };
-    const newStacks = currentStacks + 1;
-    messages.push(`✨ 【光影之刃】生效：获得1层「光影之刃」`);
     return {
       messages,
-      targetUpdates
+      targetUpdates,
+      reductionSuccess
     };
-  }, "handleBladeOfLight"),
-  /** 远古预兆处理（概率免疫能量伤害）- 增加boost参数 */
-  handleAncientOmen: /* @__PURE__ */ __name(function(targetBoss, weaponData) {
-    const messages = [];
-    let isImmune = false;
-    let targetUpdates = null;
-    if (!targetBoss.skills.includes("远古预兆")) {
-      return null;
+  }, "handleWeaponLayerReduction")
+};
+function applyPassiveEffects(targetBoss, activeBosses, weaponName, damage, ignoreRate) {
+  const messages = [];
+  let immune = false;
+  let totalBuffMultiplier = 0;
+  let totalNerfMultiplier = 0;
+  let radiationLayerAdded = false;
+  let coldLayerAdded = false;
+  let energyDrained = false;
+  let layerReduced = false;
+  let bileDetonationTrigger = false;
+  const weaponData = weaponConfig[weaponName] || { type: "" };
+  let doubleAstralWind = false;
+  let isolatedImmunityMark = false;
+  const processEffect = /* @__PURE__ */ __name((effect, ...args) => {
+    const result = effect(...args);
+    if (!result) return null;
+    messages.push(...result.messages || []);
+    if (result.targetUpdates) {
+      updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
     }
-    if (weaponData.type === "热能武器") {
-      return null;
+    if (result.otherUpdates) {
+      for (const update of result.otherUpdates) {
+        updateStatsByName(update.name, update.updates);
+      }
+    }
+    return result;
+  }, "processEffect");
+  const maxStatsMap = {};
+  const allBosses = [targetBoss, ...activeBosses];
+  for (const boss of allBosses) {
+    if (!maxStatsMap[boss.name]) {
+      maxStatsMap[boss.name] = {
+        maxHP: getMaxHPByName(boss.name) || 0,
+        maxEnergy: getMaxEnergyByName(boss.name) || 0
+      };
+    }
+  }
+  const maxStatsForTarget = maxStatsMap[targetBoss.name];
+  const coldImmuneEffects = [
+    {
+      effect: BattleEffectProcessor.handleColdAdaptation,
+      args: [targetBoss, weaponName]
+    }
+  ];
+  const fireImmuneEffects = [];
+  const chanceImmuneEffects = [
+    {
+      effect: BattleEffectProcessor.handleDeadlyHit,
+      args: [targetBoss]
+    },
+    {
+      effect: BattleEffectProcessor.handleElectricField,
+      args: [targetBoss, weaponData]
+    },
+    {
+      effect: BattleEffectProcessor.handleAncientOmen,
+      args: [targetBoss, weaponData]
+    }
+  ];
+  const allImmuneEffects = [...coldImmuneEffects, ...fireImmuneEffects, ...chanceImmuneEffects];
+  for (const immuneEffect of allImmuneEffects) {
+    const result = processEffect(immuneEffect.effect, ...immuneEffect.args);
+    if (result?.isImmune) immune = true;
+  }
+  const solarFlareResult = BattleEffectProcessor.handleSolarFlare(targetBoss, weaponName, activeBosses);
+  if (solarFlareResult) {
+    isolatedImmunityMark = solarFlareResult.tempMark || false;
+    if (solarFlareResult.isImmune) immune = true;
+    messages.push(...solarFlareResult.messages);
+    if (solarFlareResult.targetUpdates) {
+      updateStatsByName(solarFlareResult.targetUpdates.name, solarFlareResult.targetUpdates.updates);
+    }
+  }
+  const carpetBombResult = BattleEffectProcessor.handleCarpetBombing(targetBoss);
+  if (carpetBombResult) {
+    isolatedImmunityMark = carpetBombResult.tempMark || false;
+    if (carpetBombResult.nerfMultiplier) {
+      totalNerfMultiplier += carpetBombResult.nerfMultiplier;
+    }
+    messages.push(...carpetBombResult.messages);
+  }
+  const damageAdjustEffects = [
+    // 单参数效果
+    { effect: BattleEffectProcessor.handleWeakForm, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleAlienShell, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleFrostHell, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleStressShellI, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleStressShellII, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleVirusCloud, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleEnergyBlackhole, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleColossalRampage, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleVomit, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleRampage, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleHyperRangeShift, args: [targetBoss] },
+    // 双参数效果
+    { effect: BattleEffectProcessor.handleStructuralArmor, args: [targetBoss, weaponData] },
+    { effect: BattleEffectProcessor.handleDisguise, args: [targetBoss, weaponName] },
+    // 多参数效果
+    { effect: BattleEffectProcessor.handleIsolated, args: [targetBoss, activeBosses, isolatedImmunityMark] },
+    { effect: BattleEffectProcessor.handleInfectedSpaceStation, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleInfernalBomb, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleHunterAlien, args: [targetBoss, activeBosses, weaponName] }
+  ];
+  for (const effectItem of damageAdjustEffects) {
+    const result = processEffect(effectItem.effect, ...effectItem.args);
+    if (result) {
+      if (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
+      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
+      bileDetonationTrigger ||= result.bileDetonationTrigger === true;
+    }
+  }
+  const mindFrenzyResult = BattleEffectProcessor.handleMindFrenzy(targetBoss);
+  if (mindFrenzyResult) {
+    messages.push(...mindFrenzyResult.messages);
+    if (mindFrenzyResult.nerfMultiplier) {
+      totalNerfMultiplier += mindFrenzyResult.nerfMultiplier;
+    }
+    doubleAstralWind = mindFrenzyResult.doubleAstralWind || false;
+  }
+  const layerDependentEffects = [
+    { effect: BattleEffectProcessor.handleVampireSaliva, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBloodlust, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBladeOfLight, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleCollapsingPulse, args: [targetBoss] }
+  ];
+  for (const effectItem of layerDependentEffects) {
+    const result = processEffect(effectItem.effect, ...effectItem.args);
+    if (result) {
+      if (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
+      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
+    }
+  }
+  const stateChangeEffects = [
+    { effect: BattleEffectProcessor.handleSuperconductor, args: [targetBoss] }
+  ];
+  for (const effectItem of stateChangeEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
+  const healingEffects = [
+    { effect: BattleEffectProcessor.handleFrostRegeneration, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFrostAura, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleSentryGun, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleMoldGrowth, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleElectricShockwave, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handlePulse, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFeeding, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBurningBurrow, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBombardmentGuide, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleOverdriveShield, args: [targetBoss, activeBosses] }
+  ];
+  for (const effectItem of healingEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
+  const burningSlimeResult = BattleEffectProcessor.handleBurningSlime(targetBoss, weaponName);
+  if (burningSlimeResult) {
+    messages.push(...burningSlimeResult.messages);
+    if (burningSlimeResult.targetUpdates) {
+      updateStatsByName(burningSlimeResult.targetUpdates.name, burningSlimeResult.targetUpdates.updates);
+    }
+    bileDetonationTrigger = burningSlimeResult.isHighStackHeal || false;
+  }
+  const bileEffects = [
+    { effect: BattleEffectProcessor.handleCorrosiveBile, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFlameBreath, args: [targetBoss, activeBosses] }
+  ];
+  for (const effectItem of bileEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
+  const astralWindResult = BattleEffectProcessor.handleAstralWind(
+    targetBoss,
+    activeBosses,
+    doubleAstralWind
+  );
+  if (astralWindResult) {
+    messages.push(...astralWindResult.messages);
+    if (astralWindResult.otherUpdates) {
+      for (const update of astralWindResult.otherUpdates) {
+        updateStatsByName(update.name, update.updates);
+      }
     }
-    const lightBladeStacks = targetBoss.skillStacks || 0;
-    const boostPerStack = 5e-3;
-    const totalBoost = lightBladeStacks * boostPerStack;
-    const baseProbability = 0.01;
-    const actualProbability = Math.min(baseProbability + totalBoost, 1);
-    if (Math.random() >= actualProbability) {
-      return null;
+  }
+  const psychicForgeResult = BattleEffectProcessor.handlePsychicForge(
+    targetBoss
+  );
+  if (psychicForgeResult) {
+    messages.push(...psychicForgeResult.messages);
+    if (psychicForgeResult.targetUpdates) {
+      updateStatsByName(psychicForgeResult.targetUpdates.name, psychicForgeResult.targetUpdates.updates);
     }
-    isImmune = true;
-    const energyGained = 100;
-    targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        energyChange: energyGained
-        // 回复100点能量
-      }
-    };
-    messages.push(`🔮 【远古预兆】触发：${(actualProbability * 100).toFixed(2)}%概率免疫非热能武器伤害，并回复${energyGained}点能量`);
-    return {
-      isImmune,
-      messages,
-      targetUpdates
-    };
-  }, "handleAncientOmen"),
-  /** 超视距穿梭处理（层数相关伤害调整） */
-  handleHyperRangeShift: /* @__PURE__ */ __name(function(targetBoss) {
-    const messages = [];
-    let nerfMultiplier = 0;
-    let buffMultiplier = 0;
-    if (!targetBoss.skills.includes("超视距穿梭")) {
-      return null;
+  }
+  const radiationResult = BattleEffectProcessor.handleRadiationEffect(targetBoss, weaponName);
+  if (radiationResult) {
+    messages.push(...radiationResult.messages);
+    if (radiationResult.buffMultiplier) {
+      totalBuffMultiplier += radiationResult.buffMultiplier;
     }
-    const currentEnergy = targetBoss.energy || 0;
-    const maxEnergy = getMaxEnergyByName(targetBoss.name);
-    const energyPercent = currentEnergy / maxEnergy;
-    if (energyPercent >= 0.6) {
-      nerfMultiplier = targetBoss.skillStacks * 0.1;
-      messages.push(`🚀 【超视距穿梭】生效：能量值≥60%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
-    } else if (energyPercent >= 0.3) {
-      nerfMultiplier = targetBoss.skillStacks * 0.05;
-      messages.push(`🚀 【超视距穿梭】生效：能量值≥30%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
-    } else if (energyPercent <= 0.1) {
-      buffMultiplier = targetBoss.skillStacks * 0.05;
-      messages.push(`🚀 【超视距穿梭】生效：能量值≤10%，受到的伤害+${(buffMultiplier * 100).toFixed(0)}%`);
+    if (radiationResult.targetUpdates) {
+      updateStatsByName(radiationResult.targetUpdates.name, radiationResult.targetUpdates.updates);
     }
-    return { nerfMultiplier, buffMultiplier, messages };
-  }, "handleHyperRangeShift"),
-  /** 灵能构造炉处理（随机获得技能）- 增加boost参数 */
-  handlePsychicForge: /* @__PURE__ */ __name(function(targetBoss) {
-    const messages = [];
-    let newSkill = null;
-    let targetUpdates = null;
-    const possibleSkills = [
-      "天启超载护盾",
-      "塌缩脉冲",
-      "地毯式轰炸",
-      "轰炸引导"
-    ];
-    if (!targetBoss.skills.includes("灵能构造炉")) {
-      return null;
+    radiationLayerAdded = radiationResult.layerAdded;
+  }
+  const coldResult = BattleEffectProcessor.handleColdEffect(targetBoss, weaponName);
+  if (coldResult) {
+    messages.push(...coldResult.messages);
+    if (coldResult.buffMultiplier) {
+      totalBuffMultiplier += coldResult.buffMultiplier;
     }
-    const baseProbability = 0.01;
-    if (Math.random() >= baseProbability) {
-      return null;
+    if (coldResult.targetUpdates) {
+      updateStatsByName(coldResult.targetUpdates.name, coldResult.targetUpdates.updates);
     }
-    const availableSkills = possibleSkills.filter(
-      (skill) => !targetBoss.skills.includes(skill)
-    );
-    if (availableSkills.length === 0) {
-      return null;
+    coldLayerAdded = coldResult.layerAdded;
+  }
+  const energyDrainResult = BattleEffectProcessor.handleWeaponEnergyDrain(targetBoss, weaponName);
+  if (energyDrainResult) {
+    messages.push(...energyDrainResult.messages);
+    if (energyDrainResult.targetUpdates) {
+      updateStatsByName(energyDrainResult.targetUpdates.name, energyDrainResult.targetUpdates.updates);
     }
-    newSkill = availableSkills[Math.floor(Math.random() * availableSkills.length)];
-    targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        skillsAdded: [newSkill]
-      }
-    };
-    messages.push(`⚙️ 【灵能构造炉】触发：${(baseProbability * 100).toFixed(2)}%概率获得新技能「${newSkill}」`);
-    return {
-      messages,
-      newSkill,
-      targetUpdates
-    };
-  }, "handlePsychicForge"),
-  // 修改后的天启超载护盾处理函数
-  handleOverdriveShield: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
-    const messages = [];
-    const otherUpdates = [];
-    if (!targetBoss.skills.includes("天启超载护盾")) {
-      return null;
+    energyDrained = energyDrainResult.success || false;
+  }
+  const layerReduceResult = BattleEffectProcessor.handleWeaponLayerReduction(targetBoss, weaponName);
+  if (layerReduceResult) {
+    messages.push(...layerReduceResult.messages);
+    if (layerReduceResult.targetUpdates) {
+      updateStatsByName(layerReduceResult.targetUpdates.name, layerReduceResult.targetUpdates.updates);
     }
-    if (Math.random() >= 0.1) {
-      return null;
+    layerReduced = layerReduceResult.reductionSuccess || false;
+  }
+  let finalDamage = damage;
+  let adjustedNerfMultiplier = totalNerfMultiplier * (1 - ignoreRate);
+  const damageMultiplier = 1 + totalBuffMultiplier - adjustedNerfMultiplier;
+  finalDamage = Math.max(1, Math.round(damage * damageMultiplier));
+  const frostEvolutionResult = BattleEffectProcessor.handleFrostEvolution(
+    targetBoss,
+    weaponName,
+    finalDamage
+    // 使用最新计算的finalDamage
+  );
+  if (frostEvolutionResult) {
+    messages.push(...frostEvolutionResult.messages);
+    if (frostEvolutionResult.targetUpdates) {
+      updateStatsByName(frostEvolutionResult.targetUpdates.name, frostEvolutionResult.targetUpdates.updates);
     }
-    const currentStacks = targetBoss.skillStacks || 0;
-    const consumedStacks = Math.floor(currentStacks / 2);
-    if (consumedStacks <= 0) {
-      return null;
+    if (frostEvolutionResult.isImmune) {
+      immune = true;
+      finalDamage = 0;
     }
-    const survivingBosses = activeBosses.filter((boss) => boss.isActive);
-    messages.push(`🛡️ 【天启超载护盾】触发：消耗${consumedStacks}层「光影之刃」`);
-    survivingBosses.forEach((boss) => {
-      const healAmount = consumedStacks * 10;
-      otherUpdates.push({
-        name: boss.name,
-        updates: { hpChange: healAmount }
-      });
-      messages.push(`为「${boss.name}」回复${healAmount}点生命值`);
-    });
-    const targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        skillStacksChanged: -consumedStacks
-        // 消耗层数
-      }
-    };
-    return {
-      messages,
-      targetUpdates,
-      otherUpdates
-    };
-  }, "handleOverdriveShield"),
-  /** 塌缩脉冲处理（额外叠加层数） */
-  handleCollapsingPulse: /* @__PURE__ */ __name(function(targetBoss) {
-    const messages = [];
-    let targetUpdates = null;
-    const maxStacks = 49;
-    if (!targetBoss.skills.includes("塌缩脉冲")) {
-      return null;
+  }
+  const flameAlienResult = BattleEffectProcessor.handleFlameAlien(
+    targetBoss,
+    weaponName,
+    finalDamage
+    // 使用最新计算的finalDamage
+  );
+  if (flameAlienResult) {
+    messages.push(...flameAlienResult.messages);
+    if (flameAlienResult.targetUpdates) {
+      updateStatsByName(flameAlienResult.targetUpdates.name, flameAlienResult.targetUpdates.updates);
     }
-    const currentStacks = targetBoss.skillStacks || 0;
-    if (currentStacks >= maxStacks) {
-      return null;
+    if (flameAlienResult.isImmune) {
+      immune = true;
+      finalDamage = 0;
     }
-    targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        skillStacksChanged: 1
-      }
-    };
-    const newStacks = currentStacks + 1;
-    messages.push(`🌀 【塌缩脉冲】生效：额外获得1层「光影之刃」`);
-    return {
-      messages,
-      targetUpdates
-    };
-  }, "handleCollapsingPulse"),
-  /** 地毯式轰炸处理 */
-  handleCarpetBombing: /* @__PURE__ */ __name(function(targetBoss) {
-    const messages = [];
-    let nerfMultiplier = 0;
-    if (!targetBoss.skills.includes("地毯式轰炸")) {
-      return null;
+  }
+  const cosmicEnergyResult = BattleEffectProcessor.handleCosmicEnergy(
+    targetBoss,
+    finalDamage
+    // 使用最新计算的finalDamage
+  );
+  if (cosmicEnergyResult) {
+    messages.push(...cosmicEnergyResult.messages);
+    if (cosmicEnergyResult.targetUpdates) {
+      updateStatsByName(cosmicEnergyResult.targetUpdates.name, cosmicEnergyResult.targetUpdates.updates);
     }
-    nerfMultiplier = 0.8;
-    messages.push(`💣 【地毯式轰炸】生效：受到的伤害-80%`);
-    return { nerfMultiplier, messages, tempMark: true };
-  }, "handleCarpetBombing"),
-  // 修改后的轰炸引导处理函数
-  handleBombardmentGuide: /* @__PURE__ */ __name(function(targetBoss) {
-    const messages = [];
-    if (!targetBoss.skills.includes("轰炸引导")) {
-      return null;
+  }
+  if (immune) {
+    finalDamage = 0;
+  }
+  const isLethal = finalDamage >= targetBoss.HP && finalDamage > 0;
+  const survivalSkills = [
+    { func: BattleEffectProcessor.handleSurvivalInstinctI, name: "求生本能I" },
+    { func: BattleEffectProcessor.handleSurvivalInstinctII, name: "求生本能II" },
+    { func: BattleEffectProcessor.handleRevival, name: "复苏" }
+  ];
+  let revivalTriggered = false;
+  if (isLethal) {
+    for (const skill of survivalSkills) {
+      if (targetBoss.skills.includes(skill.name)) {
+        const result = skill.func(targetBoss, finalDamage);
+        if (result) {
+          updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
+          messages.push(...result.messages);
+          revivalTriggered = true;
+          break;
+        }
+      }
     }
-    if (Math.random() >= 0.1) {
-      return null;
+  }
+  if (!revivalTriggered && !immune && finalDamage > 0) {
+    updateStatsByName(targetBoss.name, {
+      hpChange: -finalDamage
+    });
+  }
+  return {
+    finalDamage,
+    messages,
+    radiationLayerAdded,
+    coldLayerAdded,
+    energyDrained,
+    layerReduced,
+    bileDetonationTrigger
+  };
+}
+__name(applyPassiveEffects, "applyPassiveEffects");
+
+// src/boss/passive.ts
+var passiveConfig = {
+  "弱化形态": {
+    type: "伤害增减（负面）",
+    description: "子代防御脆弱，受到的伤害提高10%"
+  },
+  "异形甲壳": {
+    type: "伤害增减（正面）",
+    description: "受到的伤害降低20%"
+  },
+  "冰霜回复": {
+    type: "生存强化（生命回复）",
+    description: "生命值≤30%时，立即回复自身40%最大生命值，并为所有其他存活异形回复10%最大生命值（生效后移除）"
+  },
+  "冰霜进化": {
+    type: "状态免疫（寒冷伤害免疫）",
+    description: "免疫寒冷伤害，受到寒冷攻击时回复等量生命值"
+  },
+  "冰霜环绕": {
+    type: "生存强化（生命回复+群体增益）",
+    description: "生命值≤30%时，立即回复自身45%最大生命值，并使所有存活异形获得「寒霜地狱」技能（生效后移除）"
+  },
+  "寒霜地狱": {
+    type: "伤害增减（正面）",
+    description: "受到的伤害降低30%"
+  },
+  "应激甲壳I": {
+    type: "伤害增减（正面）",
+    description: "受到的伤害降低20%"
+  },
+  "应激甲壳II": {
+    type: "伤害增减（正面）",
+    description: "受到的伤害降低25%"
+  },
+  "求生本能I": {
+    type: "生存强化（生命回复）",
+    description: "濒死时立即回复自身30%最大生命值（生效后移除）"
+  },
+  "求生本能II": {
+    type: "生存强化（生命回复）",
+    description: "濒死时立即回复自身50%最大生命值（生效后移除）"
+  },
+  "冷适应": {
+    type: "状态免疫（寒冷伤害免疫）",
+    description: "累计承受10次寒冷伤害后，获得「惧热」标签并永久免疫寒冷伤害"
+  },
+  "感染空间站": {
+    type: "伤害增减（正面）",
+    description: "当空间站哨枪塔存活时，自身受到的伤害降低50%"
+  },
+  "病毒云": {
+    type: "伤害增减（正面）",
+    description: "受到的伤害降低10%"
+  },
+  "霉菌滋生": {
+    type: "生存强化（生命回复）",
+    description: "受击后，若空间站哨枪塔存活，为其回复1%最大生命值"
+  },
+  "岗哨机枪": {
+    type: "生存强化（生命回复）",
+    description: "每累计承受10次攻击，为所有其他存活异形回复10%最大生命值"
+  },
+  "结构装甲": {
+    type: "伤害增减（正面）",
+    description: "受实弹/能量武器伤害降低20%，受热能武器伤害降低40%"
+  },
+  "吸血唾液": {
+    type: "伤害增减（正面）",
+    description: "受击获得1层「吸血唾液」(上限20层)，每层使受到的伤害降低5%"
+  },
+  "进食": {
+    type: "生存强化（生命回复）",
+    description: "「吸血唾液」≥20层时，下次受击消耗所有层数并回复自身20%最大生命值"
+  },
+  "嗜血狂暴": {
+    type: "伤害增减（正面）",
+    description: "生命值≤50%时，受击额外获得1层「吸血唾液」且受到的伤害降低20%"
+  },
+  "吐血": {
+    type: "伤害增减（负面）",
+    description: "无「吸血唾液」层数时，受到的伤害提高20%"
+  },
+  "超导体": {
+    type: "状态转换（护盾→重甲）",
+    description: "生命值≤10%时，护盾标签永久转换为重甲标签"
+  },
+  "能量虹吸": {
+    type: "伤害增减（正面）",
+    description: "生命值≥70%时伤害降低40%，30%-70%时伤害降低20%"
+  },
+  "能源虹吸": {
+    type: "伤害增减（正面）",
+    description: "能量值≥80%时伤害降低50%，50%-80%时伤害降低30%"
+  },
+  "电能立场": {
+    type: "状态免疫（伤害免疫）",
+    description: "能量值≥30%时，55%概率免疫非热能伤害（每层寒冷降低5%触发概率）"
+  },
+  "电能冲击波": {
+    type: "生存强化（能量回复）",
+    description: "受击后回复100点能量"
+  },
+  "脉冲": {
+    type: "生存强化（生命回复）",
+    description: "能量值≥30%时，60%概率为所有存活异形回复100点生命（每层寒冷降低5%触发概率）"
+  },
+  "能量黑洞": {
+    type: "伤害增减（正面）",
+    description: "存在能量黑洞时，受到的伤害降低20%"
+  },
+  "火焰异形": {
+    type: "状态免疫（火焰伤害免疫）",
+    description: "免疫火焰伤害，受到火焰攻击时回复等量生命值"
+  },
+  "庞兽狂暴": {
+    type: "伤害增减（正面）",
+    description: "生命值≤50%时，受到的伤害降低50%"
+  },
+  "灼烧粘液": {
+    type: "生存强化（生命回复）",
+    description: "受击获得1层「灼烧粘液」；受火焰攻击时消耗所有层数并回复（层数×10）点生命"
+  },
+  "腐蚀胆汁": {
+    type: "生存强化（生命回复）",
+    description: "「灼烧粘液」≥10层时，下次受击消耗所有层数并为所有存活异形回复1000点生命"
+  },
+  "火焰吐息": {
+    type: "生存强化（生命回复）",
+    description: "「灼烧粘液」≥20层时，下次攻击消耗所有层数并为所有存活异形回复20%最大生命值"
+  },
+  "太阳耀斑": {
+    type: "状态移除+状态免疫（寒冷伤害免疫）",
+    description: "所有子代阵亡后，移除惧寒标签和孤立无援状态，并永久免疫寒冷伤害"
+  },
+  "燃烧潜地": {
+    type: "生存强化（生命回复）",
+    description: "生命值≤10%时立即回复50%最大生命值（生效后移除）"
+  },
+  "炼狱爆弹": {
+    type: "伤害增减（正面）",
+    description: "每层「灼烧粘液」使受到的伤害降低5%，存活子代存在时每层额外降低5%"
+  },
+  "猎手异形": {
+    type: "伤害增减（条件性）+状态免疫（火焰/寒冷伤害免疫）",
+    description: "存在其他存活异形时伤害降低20%，无其他存活异形时伤害提高20%；免疫火焰及寒冷伤害"
+  },
+  "狂暴": {
+    type: "伤害增减（正面）",
+    description: "生命值≤50%时，受到的伤害降低50%"
+  },
+  "伪装": {
+    type: "伤害增减（正面）",
+    description: "受击记录伤害来源武器名称，下次被同名武器攻击时伤害降低80%"
+  },
+  "致命一击": {
+    type: "状态免疫（伤害免疫）",
+    description: "受击时5%概率免疫该次伤害"
+  },
+  "星界之风": {
+    type: "生存强化（生命回复）",
+    description: "受击时5%概率为所有存活异形回复200点生命"
+  },
+  "心灵狂热": {
+    type: "伤害增减（正面）",
+    description: "生命值<50%时伤害降低20%且「星界之风」触发概率翻倍"
+  },
+  "宇宙能量": {
+    type: "生存强化（能量/生命回复）",
+    description: "受击回复等量能量值，能量溢出时转换为生命回复"
+  },
+  "复苏": {
+    type: "生存强化（生命/能量回复）",
+    description: "免疫致命伤害，回复60%最大生命与100%能量值，并获得「灵能构造炉」技能（生效后移除）"
+  },
+  "光影之刃": {
+    type: "状态叠加（层数叠加）",
+    description: "受击获得1层「光影之刃」(上限50层)"
+  },
+  "远古预兆": {
+    type: "状态免疫（伤害免疫）+状态增强（触发概率提升）",
+    description: "受击时1%概率免疫非热能伤害并回复100点能量，每层「光影之刃」使触发概率提升0.5%"
+  },
+  "超视距穿梭": {
+    type: "伤害增减（条件性）",
+    description: "能量≥60%时每层「光影之刃」使伤害降低10%，30%-60%时每层降低5%，能量≤10%时每层提高5%"
+  },
+  "灵能构造炉": {
+    type: "状态获得（技能获得）",
+    description: "受击时5%概率随机获得以下技能之一：天启超载护盾/塌缩脉冲/地毯式轰炸/轰炸引导"
+  },
+  "天启超载护盾": {
+    type: "生存强化（生命回复）",
+    description: "受击时10%概率触发，消耗当前「光影之刃」层数的一半（向下取整），并为所有存活异形回复（消耗层数×10）点生命"
+  },
+  "塌缩脉冲": {
+    type: "状态叠加（层数叠加）",
+    description: "受击后额外获得1层「光影之刃」"
+  },
+  "地毯式轰炸": {
+    type: "状态移除+伤害增减（正面）",
+    description: "移除孤立无援状态，受到的伤害降低80%"
+  },
+  "轰炸引导": {
+    type: "生存强化（能量回复）",
+    description: "受击时10%概率触发，消耗当前「光影之刃」层数的一半（向下取整），并回复（消耗层数×10）点能量"
+  }
+};
+
+// src/wish.ts
+var wishConfig = {
+  // 普通祈愿（总概率 5 * 19=95%）
+  common: [
+    {
+      name: "蚱蜢优购",
+      effect: "下一次购买武器(非传奇)享有20%的折扣"
+    },
+    {
+      name: "灵狐升运",
+      effect: "下一次升级武器享有20%的折扣"
+    },
+    {
+      name: "王权增幅",
+      effect: "攻击伤害+10%"
+    },
+    {
+      name: "金柚赐福",
+      effect: "立即获得250枚金币"
+    },
+    {
+      name: "夜市赠礼",
+      effect: "立即获得5枚咕咕币"
     }
-    const currentStacks = targetBoss.skillStacks || 0;
-    const consumedStacks = Math.floor(currentStacks / 2);
-    if (consumedStacks <= 0) {
-      return null;
+  ],
+  // 稀有祈愿（总概率 5 * 1=5%）
+  rare: [
+    {
+      name: "悲鸣之锋",
+      effect: "攻击伤害+10% (武器等级0)，每级武器等级额外+10%"
+    },
+    {
+      name: "精灵双倍",
+      effect: "下一次击败主宰时可获得双倍的金币和咕咕币奖励"
+    },
+    {
+      name: "喵喵财源",
+      effect: "签到获得双倍的金币和咕咕币"
+    },
+    {
+      name: "暴击韵律",
+      effect: "攻击暴击率+20%"
+    },
+    {
+      name: "酥手空空",
+      effect: "立即失去50枚金币"
     }
-    const energyGained = consumedStacks * 10;
-    const targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        skillStacksChanged: -consumedStacks,
-        // 消耗层数
-        energyChange: energyGained
-        // 回复能量
+  ]
+};
+
+// src/utils.ts
+async function gachaWithPity(ctx, handle) {
+  const [record] = await ctx.database.get("ggcevo_records", { handle });
+  const currentPity = record?.pityCounter ?? 0;
+  if (currentPity >= 89) {
+    await updatePityCounter(ctx, handle, true);
+    await ctx.database.upsert("ggcevo_records", [{
+      handle,
+      fullPityCount: (record?.fullPityCount || 0) + 1
+    }], ["handle"]);
+    return true;
+  }
+  const isWin = simpleDraw();
+  await updatePityCounter(ctx, handle, isWin);
+  return isWin;
+}
+__name(gachaWithPity, "gachaWithPity");
+async function gachaWithHiddenAward(ctx, handle) {
+  const backpackItems = await ctx.database.get("ggcevo_backpack", {
+    handle,
+    itemId: { $in: [2, 3] }
+  });
+  const itemMap = new Map(backpackItems.map((item) => [item.itemId, item]));
+  const isWin = HiddenAward();
+  if (isWin) {
+    const updates = [
+      {
+        itemId: 2,
+        addAmount: 1
+      },
+      {
+        itemId: 3,
+        addAmount: 1
       }
-    };
-    messages.push(`🎯 【轰炸引导】触发：消耗${consumedStacks}层「光影之刃」，获得${energyGained}点能量`);
-    return {
-      messages,
-      targetUpdates
-    };
-  }, "handleBombardmentGuide"),
-  // 统一的辐射效果处理函数
-  handleRadiationEffect: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
-    const messages = [];
-    let layerAdded = false;
-    const currentLayers = targetBoss.radiationLayers || 0;
-    const effectiveLayers = Math.min(currentLayers, 20);
-    const buffMultiplier = effectiveLayers * 0.025;
-    if (effectiveLayers > 0) {
-      messages.push(`☢️ 【辐射增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
-      if (currentLayers > 20) {
+    ].map(({ itemId, addAmount }) => ({
+      handle,
+      itemId,
+      quantity: (itemMap.get(itemId)?.quantity || 0) + addAmount
+    }));
+    await ctx.database.upsert("ggcevo_backpack", updates, ["handle", "itemId"]);
+    const [record] = await ctx.database.get("ggcevo_records", { handle });
+    await ctx.database.upsert("ggcevo_records", [{
+      handle,
+      hiddenawards: (record?.hiddenawards || 0) + 1
+    }], ["handle"]);
+  }
+  return isWin;
+}
+__name(gachaWithHiddenAward, "gachaWithHiddenAward");
+async function updatePityCounter(ctx, handle, isWin) {
+  const [record] = await ctx.database.get("ggcevo_records", { handle });
+  const [backpack] = await ctx.database.get("ggcevo_backpack", { handle, itemId: 2 });
+  await ctx.database.upsert("ggcevo_records", [{
+    handle,
+    totalPulls: (record?.totalPulls || 0) + 1,
+    pityCounter: isWin ? 0 : (record?.pityCounter || 0) + 1
+  }], ["handle"]);
+  if (isWin) {
+    await ctx.database.upsert("ggcevo_backpack", [{
+      handle,
+      itemId: 2,
+      quantity: (backpack?.quantity || 0) + 1
+    }]);
+  }
+}
+__name(updatePityCounter, "updatePityCounter");
+async function checkSensitiveWord(ctx, content) {
+  try {
+    const response = await ctx.http("get", `https://v.api.aa1.cn/api/api-mgc/index.php?msg=${encodeURIComponent(content)}`);
+    return response.data.num !== "1";
+  } catch (error) {
+    console.error("敏感词查询失败:", error);
+    return false;
+  }
+}
+__name(checkSensitiveWord, "checkSensitiveWord");
+function simpleDraw() {
+  return Math.floor(Math.random() * 1e4) < 50;
+}
+__name(simpleDraw, "simpleDraw");
+function HiddenAward() {
+  return Math.floor(Math.random() * 1e4) < 1;
+}
+__name(HiddenAward, "HiddenAward");
+function getRandomInt(min, max) {
+  const actualMin = Math.min(min, max);
+  const actualMax = Math.max(min, max);
+  return Math.floor(Math.random() * (actualMax - actualMin + 1)) + actualMin;
+}
+__name(getRandomInt, "getRandomInt");
+function PetCapsuleToy() {
+  const num = Math.floor(Math.random() * 1e4);
+  if (num < 4e3) return "t3级宠物扭蛋";
+  if (num < 7e3) return "t2级宠物扭蛋";
+  if (num < 9e3) return "t1级宠物扭蛋";
+  return "t0级宠物扭蛋";
+}
+__name(PetCapsuleToy, "PetCapsuleToy");
+function isSameDate(a, b) {
+  return a.getUTCFullYear() === b.getUTCFullYear() && a.getUTCMonth() === b.getUTCMonth() && a.getUTCDate() === b.getUTCDate();
+}
+__name(isSameDate, "isSameDate");
+function isSameHalfDay(a, b) {
+  if (!isSameDate(a, b)) {
+    return false;
+  }
+  const hour1 = a.getUTCHours();
+  const hour2 = b.getUTCHours();
+  return hour1 < 12 && hour2 < 12 || hour1 >= 12 && hour2 >= 12;
+}
+__name(isSameHalfDay, "isSameHalfDay");
+function convertUTCtoChinaTime(input) {
+  const utcDate = new Date(input);
+  if (isNaN(utcDate.getTime())) {
+    throw new Error("Invalid date input");
+  }
+  const chinaTimestamp = utcDate.getTime() + 8 * 60 * 60 * 1e3;
+  return new Date(chinaTimestamp);
+}
+__name(convertUTCtoChinaTime, "convertUTCtoChinaTime");
+function formatDate(d) {
+  return d.toLocaleString("zh-CN", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+__name(formatDate, "formatDate");
+function createHpBar(current, max) {
+  const ratio = current / max;
+  const filled = Math.floor(ratio * 20);
+  return "▰".repeat(filled) + "▱".repeat(20 - filled);
+}
+__name(createHpBar, "createHpBar");
+async function activateNextBossGroup(ctx, currentBossId = null) {
+  let availableIndices = [];
+  bossPool.forEach((bossGroup, index) => {
+    if (currentBossId === null || bossGroup.id !== currentBossId) {
+      availableIndices.push(index);
+    }
+  });
+  if (availableIndices.length === 0) {
+    availableIndices = Array.from({ length: bossPool.length }, (_, i) => i);
+  }
+  const randomIndex = availableIndices[Math.floor(Math.random() * availableIndices.length)];
+  const nextBossGroup = bossPool[randomIndex];
+  const mainBoss = await ctx.database.create("ggcevo_boss", {
+    name: nextBossGroup.main.name,
+    type: nextBossGroup.main.type,
+    HP: nextBossGroup.main.maxHP,
+    tags: nextBossGroup.main.tags,
+    // 新增标签字段
+    skills: [...nextBossGroup.main.passive],
+    energy: nextBossGroup.main.maxEnergy,
+    groupId: nextBossGroup.id,
+    isActive: true,
+    respawnTime: /* @__PURE__ */ new Date()
+  });
+  for (const minion of nextBossGroup.minions) {
+    await ctx.database.create("ggcevo_boss", {
+      name: minion.name,
+      type: minion.type,
+      HP: minion.maxHP,
+      tags: minion.tags,
+      // 新增标签字段
+      skills: [...minion.passive],
+      energy: minion.maxEnergy,
+      groupId: nextBossGroup.id,
+      isActive: true,
+      respawnTime: /* @__PURE__ */ new Date()
+    });
+  }
+  return mainBoss;
+}
+__name(activateNextBossGroup, "activateNextBossGroup");
+var weaponConfigById = {};
+for (const key in weaponConfig) {
+  weaponConfigById[weaponConfig[key].id] = weaponConfig[key];
+}
+async function calculateTotalPower(ctx, config, handle) {
+  const [rankData] = await ctx.database.get("ggcevo_rank", {
+    handle,
+    rankseason: config.rankseason
+  });
+  const baseRank = rankData?.rank || 0;
+  let total = baseRank;
+  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
+  const career = careerData?.career;
+  if (career) {
+    if (career === "联盟新兵") total += 1e3;
+    else if (career === "辛迪加炮灰新兵") total += 2e3;
+    else if (["深空矿工", "医疗专家", "情报副官", "总工程师", "舰长", "机械化专家"].includes(career)) total += 2500;
+    else if (["清洁工", "辛迪加财务经理", "计算机专家", "指挥官", "装甲兵", "破坏者", "征募官"].includes(career)) total += 3e3;
+    else if (["警卫员下士", "警卫长", "武器中士"].includes(career)) total += 3500;
+    else if (["能量武器专家", "枪手", "猩红杀手", "纵火狂"].includes(career)) total += 4e3;
+  }
+  const weapons = await ctx.database.get("ggcevo_weapons", { handle });
+  for (const { weaponId, level, installedMods } of weapons) {
+    const weapon = weaponConfigById[weaponId];
+    if (!weapon) continue;
+    total += weapon.damage * 100;
+    total += level * (level + 1) / 2 * 1e3;
+    for (const modName of installedMods || []) {
+      const mod = modConfig[modName];
+      if (mod) {
+        if (mod.isExclusive) {
+          total += 4e3;
+        } else {
+          total += 2e3;
+        }
       }
     }
-    let targetUpdates = null;
-    if (weaponName === "伽马枪" && // 使用伽马枪
-    !targetBoss.tags.includes("机械") && // 非机械目标
-    targetBoss.tags.includes("生物")) {
-      targetUpdates = {
-        name: targetBoss.name,
-        updates: {
-          radiationLayersChange: 1
-          // 辐射层数增加1
-        }
+  }
+  return total;
+}
+__name(calculateTotalPower, "calculateTotalPower");
+async function applyItemEffect(ctx, session, handle, itemConfig2, target) {
+  try {
+    const itemName = Object.entries(SyndicatedItems).find(
+      ([_, item]) => item.id === itemConfig2.id
+    )?.[0] || "未知物品";
+    if (itemConfig2.id === 1) {
+      const activeSentry = await ctx.database.get("ggcevo_boss", {
+        name: "空间站哨枪塔",
+        isActive: true
+      });
+      if (!activeSentry.length) return {
+        success: false,
+        message: "⚠️ 目标「空间站哨枪塔」未存活"
+      };
+      const [SentryTower] = await ctx.database.get("ggcevo_boss", {
+        name: "空间站哨枪塔",
+        isActive: true
+      });
+      const damageValue = SentryTower.HP;
+      await ctx.database.set(
+        "ggcevo_boss",
+        { name: "空间站哨枪塔" },
+        { isActive: false, HP: 0 }
+      );
+      await ctx.database.withTransaction(async () => {
+        const signRecords = await ctx.database.get("ggcevo_sign", { handle });
+        await ctx.database.upsert("ggcevo_sign", [{
+          handle,
+          totalRewards: (signRecords[0]?.totalRewards || 0) + damageValue
+        }], ["handle"]);
+        const [damageRecords] = await ctx.database.get("ggcevo_boss_damage", { handle });
+        await ctx.database.upsert("ggcevo_boss_damage", [{
+          handle,
+          playerName: session.username,
+          totalDamage: (damageRecords?.totalDamage || 0) + damageValue,
+          attackCount: damageRecords?.attackCount || 0,
+          bossGroupId: 4
+        }], ["handle"]);
+      });
+      return {
+        success: true,
+        message: `成功引爆${itemName}，对空间站哨枪塔造成${damageValue}点伤害，获得等额金币。`
       };
-      const newLayers = currentLayers + 1;
-      messages.push(`☢️ 【伽马枪】武器效果：获得1层「辐射」`);
-      layerAdded = true;
     }
-    return {
-      messages,
-      targetUpdates,
-      buffMultiplier,
-      layerAdded
-      // 返回层数增加标记
-    };
-  }, "handleRadiationEffect"),
-  // 统一的寒冷效果处理函数
-  handleColdEffect: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
-    const messages = [];
-    let layerAdded = false;
-    const currentLayers = targetBoss.coldLayers || 0;
-    const effectiveLayers = Math.min(currentLayers, 20);
-    const buffMultiplier = effectiveLayers * 0.025;
-    if (effectiveLayers > 0) {
-      messages.push(`❄️ 【寒冷增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
-      if (currentLayers > 20) {
+    if (itemConfig2.id === 2) {
+      if (!target) return {
+        success: false,
+        message: "您未选择合适的目标。"
+      };
+      const [targetboss] = await ctx.database.get("ggcevo_boss", {
+        name: target,
+        isActive: true
+      });
+      if (!targetboss) return {
+        success: false,
+        message: "无法找到指定的目标。"
+      };
+      if (targetboss.tags.includes("建筑") || targetboss.tags.includes("重型")) {
+        return {
+          success: false,
+          message: `目标${target}拥有"${targetboss.tags.includes("建筑") ? "建筑" : "重型"}"标签，无法使用此物品。`
+        };
       }
-    }
-    let targetUpdates = null;
-    if (weaponName === "零度之下") {
-      targetUpdates = {
-        name: targetBoss.name,
-        updates: {
-          coldLayersChange: 1
-          // 寒冷层数增加1
-        }
+      const currentCount = targetboss?.skillStacks || 0;
+      if (currentCount <= 0) {
+        return {
+          success: false,
+          message: `目标${target}的技能层数已为0，无需使用此物品。`
+        };
+      }
+      const newCount = Math.max(0, currentCount - 10);
+      const reducedAmount = currentCount - newCount;
+      await ctx.database.set(
+        "ggcevo_boss",
+        { name: target },
+        { skillStacks: newCount }
+      );
+      return {
+        success: true,
+        message: `成功使用${itemName}，使${target}的技能层数减少10层`
       };
-      const newLayers = currentLayers + 1;
-      messages.push(`❄️【零度之下】武器效果： 获得1层「寒冷」`);
-      layerAdded = true;
-    }
-    return {
-      messages,
-      targetUpdates,
-      buffMultiplier,
-      layerAdded
-      // 返回层数增加标记
-    };
-  }, "handleColdEffect"),
-  // 统一的武器能量消耗处理函数
-  handleWeaponEnergyDrain: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
-    const weaponEnergyDrain = {
-      "弧焊枪": 200,
-      "DG-3电弧步枪": 500
-    };
-    const drainValue = weaponEnergyDrain[weaponName];
-    if (!drainValue) {
-      return null;
     }
-    const messages = [];
-    const success = drainValue > 0;
-    let targetUpdates = null;
-    if (success) {
-      targetUpdates = {
-        name: targetBoss.name,
-        updates: {
-          energyChange: -drainValue
-          // 消耗能量（负值）
-        }
+    if (itemConfig2.id === 4) {
+      if (!target) return {
+        success: false,
+        message: "您未选择合适的目标。"
+      };
+      const [targetboss] = await ctx.database.get("ggcevo_boss", {
+        name: target,
+        isActive: true
+      });
+      if (!targetboss || targetboss?.energy === 0) return {
+        success: false,
+        message: "您无法对没有能量的目标使用。"
+      };
+      await ctx.database.set(
+        "ggcevo_boss",
+        { name: target },
+        { energy: Math.max(targetboss.energy - 500, 0) }
+        // 确保不低于0
+      );
+      return {
+        success: true,
+        message: `成功使用${itemName}，消耗${target}500点能量`
       };
-    }
-    const weaponDisplayName = weaponName === "弧焊枪" ? "弧焊枪" : "DG-3电弧步枪";
-    if (success) {
-      messages.push(`⚡ 【${weaponDisplayName}】武器效果：消耗${drainValue}点能量`);
     }
     return {
-      messages,
-      targetUpdates,
-      success
-    };
-  }, "handleWeaponEnergyDrain"),
-  // 统一的武器层数减少处理函数
-  handleWeaponLayerReduction: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
-    const weaponLayerReduction = {
-      "脉冲扰乱枪": 2
-      // 可以在这里添加其他武器及其减少层数
+      success: false,
+      message: `${itemName} 无法使用。`
     };
-    const reductionAmount = weaponLayerReduction[weaponName];
-    if (!reductionAmount) {
-      return null;
-    }
-    const messages = [];
-    const reductionSuccess = reductionAmount > 0;
-    let targetUpdates = null;
-    if (reductionSuccess) {
-      targetUpdates = {
-        name: targetBoss.name,
-        updates: {
-          skillStacksChanged: -reductionAmount
-          // 减少层数
-        }
-      };
-    }
-    if (reductionSuccess) {
-      messages.push(`⚡ 【${weaponName}】武器效果：技能层数减少${reductionAmount}层`);
-    }
+  } catch (error) {
+    console.error("物品效果处理失败:", error);
     return {
-      messages,
-      targetUpdates,
-      reductionSuccess
+      success: false,
+      message: "⚠️ 物品效果处理异常，已回滚操作。"
+    };
+  }
+}
+__name(applyItemEffect, "applyItemEffect");
+async function handleTechUpgrade(ctx, handle, target) {
+  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
+  if (!careerData || careerData.group !== "人类联盟") {
+    return "🚫 该功能需要【人类联盟】阵营权限";
+  }
+  const tech = Spacestationtechnology.find(
+    (t) => t.techname === target
+  );
+  const [techEntry] = await ctx.database.get("ggcevo_tech", { handle, techId: tech.techId });
+  const currentLevel = techEntry?.level || 0;
+  if (currentLevel >= tech.maxLevel) return `❌ ${tech.techname}已达最高等级`;
+  const nextLevel = currentLevel + 1;
+  const levelData = tech.levels.find((l) => l.level === nextLevel);
+  let originalCost = levelData.cost;
+  let actualCost = originalCost;
+  let discountApplied = false;
+  let discountDetails = [];
+  if (careerData.career === "情报副官") {
+    discountApplied = true;
+    actualCost = Math.floor(originalCost * 0.9);
+    discountDetails.push("🎖️ 情报副官职业：10%折扣");
+  }
+  const [signInfo] = await ctx.database.get("ggcevo_sign", { handle });
+  if (signInfo?.totalRewards < actualCost) {
+    const priceHint = discountApplied ? ` (原价${originalCost}金币)` : "";
+    return `❌ 金币不足！需要${actualCost}金币${priceHint}，您当前拥有：${signInfo?.totalRewards || 0}金币`;
+  }
+  let permissionGrantInfo = null;
+  if (tech.techname === "武器系统" && currentLevel === 4 && nextLevel === 5) {
+    permissionGrantInfo = {
+      type: "武器系统",
+      field: "legendarypermissions",
+      amount: 1,
+      message: "🎉 解锁传奇武器购买权限1次！"
     };
-  }, "handleWeaponLayerReduction")
-};
-function applyPassiveEffects(targetBoss, activeBosses, weaponName, damage, ignoreRate) {
-  const messages = [];
-  let immune = false;
-  let totalBuffMultiplier = 0;
-  let totalNerfMultiplier = 0;
-  let radiationLayerAdded = false;
-  let coldLayerAdded = false;
-  let energyDrained = false;
-  let layerReduced = false;
-  let bileDetonationTrigger = false;
-  const weaponData = weaponConfig[weaponName] || { type: "" };
-  let doubleAstralWind = false;
-  let isolatedImmunityMark = false;
-  const processEffect = /* @__PURE__ */ __name((effect, ...args) => {
-    const result = effect(...args);
-    if (!result) return null;
-    messages.push(...result.messages || []);
-    if (result.targetUpdates) {
-      updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
-    }
-    if (result.otherUpdates) {
-      for (const update of result.otherUpdates) {
-        updateStatsByName(update.name, update.updates);
-      }
+  }
+  if (tech.techname === "安防系统" && currentLevel === 4 && nextLevel === 5) {
+    permissionGrantInfo = {
+      type: "安防系统",
+      field: "explosiondoorauthority",
+      amount: 1,
+      message: "🔓 解锁安全军械库防爆门权限1次！"
+    };
+  }
+  await ctx.database.withTransaction(async () => {
+    await ctx.database.set("ggcevo_sign", { handle }, {
+      totalRewards: signInfo.totalRewards - actualCost
+    });
+    await ctx.database.upsert("ggcevo_tech", [{
+      handle,
+      techId: tech.techId,
+      level: nextLevel
+    }], ["handle", "techId"]);
+    if (permissionGrantInfo) {
+      const [permissionRecord] = await ctx.database.get("ggcevo_permissions", { handle });
+      const currentValue = permissionRecord?.[permissionGrantInfo.field] || 0;
+      await ctx.database.upsert("ggcevo_permissions", [{
+        handle,
+        [permissionGrantInfo.field]: currentValue + permissionGrantInfo.amount
+      }], ["handle"]);
     }
-    return result;
-  }, "processEffect");
-  const coldImmuneEffects = [
-    {
-      effect: BattleEffectProcessor.handleColdAdaptation,
-      args: [targetBoss, weaponName]
+  });
+  let discountInfo = [];
+  if (discountApplied) {
+    discountInfo = [
+      "💰 折扣明细：",
+      ...discountDetails.map((detail) => `▸ ${detail}`)
+    ];
+  }
+  const costInfo = discountApplied ? `💸 花费金币：${actualCost} (原价${originalCost})` : `💸 花费金币：${actualCost}`;
+  let permissionMessage = [];
+  if (permissionGrantInfo) {
+    const [permissionRecord] = await ctx.database.get("ggcevo_permissions", { handle });
+    const newValue = permissionRecord?.[permissionGrantInfo.field] || permissionGrantInfo.amount;
+    permissionMessage.push(
+      permissionGrantInfo.message
+    );
+  }
+  return [
+    `✅ ${tech.techname} 升级至 Lv.${nextLevel}`,
+    costInfo,
+    ...discountInfo,
+    // 折扣信息
+    `📝 基础效果：${levelData.description}`,
+    `💼 职业效果：${levelData.careerBonus}`,
+    ...permissionMessage
+    // 权限解锁信息
+  ].filter(Boolean).join("\n");
+}
+__name(handleTechUpgrade, "handleTechUpgrade");
+async function handleWeaponUpgrade(ctx, handle, target) {
+  const weaponData = weaponConfig[target];
+  const [equipment] = await ctx.database.get("ggcevo_weapons", {
+    handle,
+    weaponId: weaponData.id
+  });
+  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
+  if (!equipment) return "❌ 您尚未获得该武器";
+  const maxLevel = careerData?.career === "枪手" ? 7 : 6;
+  if (equipment.level >= maxLevel) return `❌ 该武器已达最高等级(Lv.${maxLevel})`;
+  const BASE_COST = [1050, 1450, 1850, 2250, 2650, 3050, 3450];
+  const baseCost = BASE_COST[equipment.level];
+  const weaponTechConfig = Spacestationtechnology.find((t) => t.techId === 2);
+  let techLevel = 0;
+  let totalDiscount = 0;
+  const discountDetails = [];
+  const isGunslinger = careerData?.career === "枪手";
+  if (isGunslinger) {
+    totalDiscount += 10;
+    discountDetails.push("🔫 枪手职业：10%折扣");
+  }
+  if (careerData?.group === "人类联盟") {
+    const [weaponTech] = await ctx.database.get("ggcevo_tech", { handle, techId: 2 }).catch(() => [{ level: 0 }]);
+    techLevel = Math.min(Math.max(weaponTech?.level || 0, 0), 5);
+    const isCareerMatch = weaponTechConfig?.careerNames.includes(careerData?.career);
+    const BASE_DISCOUNTS = [5, 10, 15, 20, 25];
+    const CAREER_DISCOUNTS = [10, 20, 30, 40, 50];
+    const baseDiscount = techLevel > 0 ? BASE_DISCOUNTS[techLevel - 1] : 0;
+    const careerDiscount = isCareerMatch && techLevel > 0 ? CAREER_DISCOUNTS[techLevel - 1] : 0;
+    const weaponDiscount = Math.max(baseDiscount, careerDiscount);
+    if (weaponDiscount > 0) {
+      totalDiscount += weaponDiscount;
+      discountDetails.push(
+        `⚙️ 武器系统Lv.${techLevel}：${weaponDiscount}%折扣`
+      );
     }
-  ];
-  const fireImmuneEffects = [];
-  const chanceImmuneEffects = [
-    {
-      effect: BattleEffectProcessor.handleDeadlyHit,
-      args: [targetBoss]
-    },
-    {
-      effect: BattleEffectProcessor.handleElectricField,
-      args: [targetBoss, weaponData]
-    },
-    {
-      effect: BattleEffectProcessor.handleAncientOmen,
-      args: [targetBoss, weaponData]
+  }
+  const activeWish = await checkFoxBlessing(ctx, handle);
+  if (activeWish) {
+    totalDiscount += 20;
+    discountDetails.push("🦊 灵狐升运祈愿：20%折扣");
+  }
+  totalDiscount = Math.min(totalDiscount, 100);
+  const discountedCost = baseCost * (100 - totalDiscount) / 100;
+  const actualCost = Math.floor(discountedCost);
+  const [signInfo] = await ctx.database.get("ggcevo_sign", { handle });
+  if (signInfo?.totalRewards < actualCost) {
+    const priceInfo2 = totalDiscount > 0 ? `需要${actualCost}金币(原价${baseCost}金币)` : `需要${actualCost}金币`;
+    return `❌ ${priceInfo2}，您当前拥有：${signInfo?.totalRewards || 0}金币`;
+  }
+  const newLevel = equipment.level + 1;
+  const newModSlots = Math.floor(newLevel / 3) + 1;
+  await ctx.database.withTransaction(async () => {
+    await ctx.database.set("ggcevo_sign", { handle }, {
+      totalRewards: signInfo.totalRewards - actualCost
+    });
+    await ctx.database.set(
+      "ggcevo_weapons",
+      { handle, weaponId: weaponData.id },
+      {
+        level: newLevel,
+        modificationSlots: newModSlots
+      }
+    );
+    if (activeWish) {
+      await ctx.database.set(
+        "ggcevo_wish",
+        { id: activeWish.id },
+        { isused: true }
+      );
     }
-  ];
-  const allImmuneEffects = [...coldImmuneEffects, ...fireImmuneEffects, ...chanceImmuneEffects];
-  for (const immuneEffect of allImmuneEffects) {
-    const result = processEffect(immuneEffect.effect, ...immuneEffect.args);
-    if (result?.isImmune) immune = true;
+  });
+  const damage = (weaponData.damage * (1 + 0.1 * newLevel)).toFixed(1);
+  let msg = `${target} 升级成功！Lv.${newLevel}`;
+  const priceInfo = totalDiscount > 0 ? `
+💸 花费：${actualCost}金币 (原价${baseCost}金币)` : `
+💸 花费：${actualCost}金币`;
+  msg += priceInfo;
+  if (discountDetails.length > 0) {
+    msg += `
+💰 折扣明细：
+▸ ${discountDetails.join("\n▸ ")}`;
   }
-  const solarFlareResult = BattleEffectProcessor.handleSolarFlare(targetBoss, weaponName, activeBosses);
-  if (solarFlareResult) {
-    isolatedImmunityMark = solarFlareResult.tempMark || false;
-    if (solarFlareResult.isImmune) immune = true;
-    messages.push(...solarFlareResult.messages);
-    if (solarFlareResult.targetUpdates) {
-      updateStatsByName(solarFlareResult.targetUpdates.name, solarFlareResult.targetUpdates.updates);
+  msg += `
+💥 伤害：${damage}`;
+  msg += `
+🔧 改装槽：${newModSlots}个`;
+  return msg;
+}
+__name(handleWeaponUpgrade, "handleWeaponUpgrade");
+async function checkFoxBlessing(ctx, handle) {
+  return ctx.database.get("ggcevo_wish", {
+    handle,
+    wishname: "灵狐升运",
+    startTime: { $lte: /* @__PURE__ */ new Date() },
+    endTime: { $gte: /* @__PURE__ */ new Date() },
+    isused: false
+  }).then((records) => records[0]);
+}
+__name(checkFoxBlessing, "checkFoxBlessing");
+async function generateUpgradePriceList(ctx, handle) {
+  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
+  const isGunslinger = careerData?.career === "枪手";
+  const isAlliance = careerData?.group === "人类联盟";
+  let techLevel = 0;
+  let techDiscountRate = 0;
+  let hasTechDiscount = false;
+  if (isAlliance) {
+    const [techData] = await ctx.database.get("ggcevo_tech", { handle, techId: 2 }).catch(() => [{ level: 0 }]);
+    const weaponTechConfig = Spacestationtechnology.find((t) => t.techId === 2);
+    techLevel = Math.min(techData?.level || 0, 5);
+    const isCareerMatch = weaponTechConfig?.careerNames.includes(careerData?.career);
+    const BASE_DISCOUNTS = [5, 10, 15, 20, 25];
+    const CAREER_DISCOUNTS = [10, 20, 30, 40, 50];
+    const baseDiscount = techLevel > 0 ? BASE_DISCOUNTS[techLevel - 1] : 0;
+    const careerDiscount = isCareerMatch ? CAREER_DISCOUNTS[techLevel - 1] : 0;
+    techDiscountRate = Math.max(baseDiscount, careerDiscount);
+    hasTechDiscount = techDiscountRate > 0;
+  }
+  const foxBlessing = await checkFoxBlessing(ctx, handle);
+  const foxDiscount = foxBlessing ? 20 : 0;
+  const hasFoxDiscount = foxDiscount > 0;
+  const gunslingerDiscount = isGunslinger ? 10 : 0;
+  const hasGunslingerDiscount = isGunslinger;
+  const BASE_COST = [1050, 1450, 1850, 2250, 2650, 3050, 3450];
+  const maxLevel = isGunslinger ? 7 : 6;
+  const priceDetails = [];
+  for (let i = 0; i < maxLevel; i++) {
+    const level = `${i}→${i + 1}`;
+    let baseCost = BASE_COST[i];
+    let finalPrice = baseCost;
+    let discountsApplied = [];
+    let totalDiscount = 0;
+    if (isGunslinger) {
+      totalDiscount += gunslingerDiscount;
+      discountsApplied.push(`${gunslingerDiscount}% (枪手)`);
+    }
+    if (isAlliance && hasTechDiscount) {
+      totalDiscount += techDiscountRate;
+      discountsApplied.push(`${techDiscountRate}% (科技)`);
     }
-  }
-  const carpetBombResult = BattleEffectProcessor.handleCarpetBombing(targetBoss);
-  if (carpetBombResult) {
-    isolatedImmunityMark = carpetBombResult.tempMark || false;
-    if (carpetBombResult.nerfMultiplier) {
-      totalNerfMultiplier += carpetBombResult.nerfMultiplier;
+    if (hasFoxDiscount) {
+      totalDiscount += foxDiscount;
+      discountsApplied.push(`${foxDiscount}% (灵狐)`);
     }
-    messages.push(...carpetBombResult.messages);
-  }
-  const damageAdjustEffects = [
-    // 单参数效果
-    { effect: BattleEffectProcessor.handleWeakForm, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleAlienShell, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleFrostHell, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleStressShellI, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleStressShellII, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleVirusCloud, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleEnergyBlackhole, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleColossalRampage, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleVomit, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleRampage, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleHyperRangeShift, args: [targetBoss] },
-    // 双参数效果
-    { effect: BattleEffectProcessor.handleStructuralArmor, args: [targetBoss, weaponData] },
-    { effect: BattleEffectProcessor.handleDisguise, args: [targetBoss, weaponName] },
-    // 多参数效果
-    { effect: BattleEffectProcessor.handleIsolated, args: [targetBoss, activeBosses, isolatedImmunityMark] },
-    { effect: BattleEffectProcessor.handleInfectedSpaceStation, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleInfernalBomb, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleHunterAlien, args: [targetBoss, activeBosses, weaponName] }
-  ];
-  for (const effectItem of damageAdjustEffects) {
-    const result = processEffect(effectItem.effect, ...effectItem.args);
-    if (result) {
-      if (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
-      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
-      bileDetonationTrigger ||= result.bileDetonationTrigger === true;
+    if (totalDiscount > 0) {
+      totalDiscount = Math.min(totalDiscount, 100);
+      finalPrice = Math.floor(baseCost * (100 - totalDiscount) / 100);
     }
-  }
-  const mindFrenzyResult = BattleEffectProcessor.handleMindFrenzy(targetBoss);
-  if (mindFrenzyResult) {
-    messages.push(...mindFrenzyResult.messages);
-    if (mindFrenzyResult.nerfMultiplier) {
-      totalNerfMultiplier += mindFrenzyResult.nerfMultiplier;
+    const showOriginal = finalPrice < baseCost;
+    const levelInfo = `等级 ${level.padEnd(5)}`;
+    const priceInfo = `▸ 价格: ${finalPrice.toString().padStart(4)}${showOriginal ? ` (原价${baseCost})` : ""}`;
+    let discountDetail = "";
+    if (discountsApplied.length > 0) {
+      discountDetail = ` - 折扣总计: ${totalDiscount}% [${discountsApplied.join(", ")}]`;
     }
-    doubleAstralWind = mindFrenzyResult.doubleAstralWind || false;
+    priceDetails.push(`${levelInfo}
+${priceInfo}`);
   }
-  const layerDependentEffects = [
-    { effect: BattleEffectProcessor.handleVampireSaliva, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleBloodlust, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleBladeOfLight, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleCollapsingPulse, args: [targetBoss] }
-  ];
-  for (const effectItem of layerDependentEffects) {
-    const result = processEffect(effectItem.effect, ...effectItem.args);
-    if (result) {
-      if (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
-      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
-    }
+  const discountNotice = [];
+  if (hasTechDiscount || hasFoxDiscount || hasGunslingerDiscount) {
+    discountNotice.push("💰 当前折扣：");
   }
-  const stateChangeEffects = [
-    { effect: BattleEffectProcessor.handleSuperconductor, args: [targetBoss] }
-  ];
-  for (const effectItem of stateChangeEffects) {
-    processEffect(effectItem.effect, ...effectItem.args);
+  if (isGunslinger) {
+    discountNotice.push(`▸ 🔫 枪手职业：10%折扣`);
   }
-  const healingEffects = [
-    { effect: BattleEffectProcessor.handleFrostRegeneration, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleFrostAura, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleSentryGun, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleMoldGrowth, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleElectricShockwave, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handlePulse, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleFeeding, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleBurningBurrow, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleBombardmentGuide, args: [targetBoss] },
-    { effect: BattleEffectProcessor.handleOverdriveShield, args: [targetBoss, activeBosses] }
-  ];
-  for (const effectItem of healingEffects) {
-    processEffect(effectItem.effect, ...effectItem.args);
+  if (isAlliance && hasTechDiscount) {
+    discountNotice.push(`▸ ⚙️ 武器系统Lv.${techLevel}：${techDiscountRate}%折扣`);
   }
-  const burningSlimeResult = BattleEffectProcessor.handleBurningSlime(targetBoss, weaponName);
-  if (burningSlimeResult) {
-    messages.push(...burningSlimeResult.messages);
-    if (burningSlimeResult.targetUpdates) {
-      updateStatsByName(burningSlimeResult.targetUpdates.name, burningSlimeResult.targetUpdates.updates);
+  if (hasFoxDiscount) {
+    discountNotice.push(`▸ 🦊 灵狐升运祈愿：20%折扣`);
+  }
+  if (!hasTechDiscount && !hasFoxDiscount && !hasGunslingerDiscount) {
+    if (isAlliance) {
+      discountNotice.push("💡 提示：升级武器系统科技可获得折扣");
+    } else if (careerData?.group === "辛迪加海盗") {
+      discountNotice.push("💡 提示：转职为枪手职业可获得折扣");
+    } else {
+      discountNotice.push("💡 提示：加入人类联盟或辛迪加海盗可获得折扣");
     }
-    bileDetonationTrigger = burningSlimeResult.isHighStackHeal || false;
   }
-  const bileEffects = [
-    { effect: BattleEffectProcessor.handleCorrosiveBile, args: [targetBoss, activeBosses] },
-    { effect: BattleEffectProcessor.handleFlameBreath, args: [targetBoss, activeBosses] }
-  ];
-  for (const effectItem of bileEffects) {
-    processEffect(effectItem.effect, ...effectItem.args);
+  if (isGunslinger) {
+    discountNotice.push("▸ 🔝 枪手职业：武器等级上限提升至7级");
   }
-  const astralWindResult = BattleEffectProcessor.handleAstralWind(
-    targetBoss,
-    activeBosses,
-    doubleAstralWind
+  return [
+    "⚡ 武器升级价格表 ⚡",
+    `武器等级上限: ${maxLevel}级${isGunslinger ? " (枪手职业)" : ""}`,
+    "使用「升级 武器名称」对武器进行等级升级",
+    ...discountNotice,
+    "====================",
+    ...priceDetails,
+    "===================="
+  ].join("\n");
+}
+__name(generateUpgradePriceList, "generateUpgradePriceList");
+async function getRankInfo(ctx, config, handle) {
+  const [user] = await ctx.database.get("ggcevo_rank", {
+    handle,
+    rankseason: config.rankseason
+  });
+  if (!user) return "暂未找到排名信息。";
+  if (user.Blacklist) return "❌ 该用户已被禁止参加本赛季胜点榜。";
+  const allRanks = await ctx.database.select("ggcevo_rank").where({ Blacklist: false, rankseason: config.rankseason }).orderBy("rank", "desc").execute();
+  const userRank = allRanks.findIndex((u) => u.handle === handle) + 1;
+  const isSafe = await checkSensitiveWord(ctx, user.name);
+  const displayName = isSafe ? user.name : (user.name[0] || "") + "***";
+  return `🎮 咕咕排名信息 🎮
+------------------------------
+昵称：${displayName}
+句柄：${user.handle}
+当前积分：${user.rank}
+参赛次数：${user.matches} 次
+胜率：${user.matches === 0 ? "0.00%" : (user.wins / user.matches * 100).toFixed(2) + "%"}
+全服排名：第 ${userRank} 名
+------------------------------`;
+}
+__name(getRankInfo, "getRankInfo");
+function isWithinProtection(protections) {
+  const now = /* @__PURE__ */ new Date();
+  return protections.some(
+    (p) => p.status === "active" && now >= p.startTime && now <= p.endTime
   );
-  if (astralWindResult) {
-    messages.push(...astralWindResult.messages);
-    if (astralWindResult.otherUpdates) {
-      for (const update of astralWindResult.otherUpdates) {
-        updateStatsByName(update.name, update.updates);
-      }
-    }
-  }
-  const psychicForgeResult = BattleEffectProcessor.handlePsychicForge(
-    targetBoss
+}
+__name(isWithinProtection, "isWithinProtection");
+function formatTime(date) {
+  return date.toLocaleString("zh-CN", {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+}
+__name(formatTime, "formatTime");
+
+// src/boss/damagecalculation.ts
+async function calculateTotalDamage(ctx, session, config, equippedWeapon, targetBoss) {
+  let effectMessage = [];
+  const finalTags = targetBoss.tags || [];
+  const [profile] = await ctx.database.get("sc2arcade_player", { userId: session.userId });
+  const { regionId, realmId, profileId } = profile;
+  const handle = `${regionId}-S2-${realmId}-${profileId}`;
+  const weaponConfigEntry = Object.entries(weaponConfig).find(([_, c]) => c.id === equippedWeapon.weaponId);
+  const [weaponName, weaponData] = weaponConfigEntry;
+  const baseDamage = weaponData.damage * (1 + 0.1 * equippedWeapon.level);
+  const levelBonusPercent = (0.1 * equippedWeapon.level * 100).toFixed(0);
+  effectMessage.push(`🔫 ${weaponName}Lv.${equippedWeapon.level}：基础伤害+${levelBonusPercent}%`);
+  let totalAdditive = 0;
+  const tagAdditive = await calculateTagMultiplier(weaponData, finalTags, equippedWeapon);
+  totalAdditive += tagAdditive;
+  const { totalModAdd, hasCrit, modMessages } = calculateModifiers(
+    equippedWeapon,
+    weaponName,
+    await checkCritRhythm(ctx, handle)
   );
-  if (psychicForgeResult) {
-    messages.push(...psychicForgeResult.messages);
-    if (psychicForgeResult.targetUpdates) {
-      updateStatsByName(psychicForgeResult.targetUpdates.name, psychicForgeResult.targetUpdates.updates);
-    }
+  totalAdditive += totalModAdd;
+  effectMessage.push(...modMessages);
+  const careerBonus = await calculateCareerAdditive(ctx, handle, weaponData.type, weaponData.id);
+  totalAdditive += careerBonus.value;
+  if (careerBonus.message) effectMessage.push(careerBonus.message);
+  const wishAdditive = await calculateWishAdditive(ctx, handle, equippedWeapon);
+  totalAdditive += wishAdditive.value;
+  if (wishAdditive.message) effectMessage.push(wishAdditive.message);
+  const [rankRecord] = await ctx.database.get("ggcevo_rank", { handle, rankseason: config.rankseason });
+  const rankAddResult = calculateRankAdditive(rankRecord);
+  totalAdditive += rankAddResult.value;
+  if (rankAddResult.message) {
+    effectMessage.push(rankAddResult.message);
+  }
+  let finalDamage = baseDamage * (1 + totalAdditive);
+  if (finalDamage < 1) {
+    finalDamage = 1;
+  }
+  return {
+    damage: Math.round(finalDamage),
+    hasCrit,
+    effectMessage
+  };
+}
+__name(calculateTotalDamage, "calculateTotalDamage");
+async function checkCritRhythm(ctx, handle) {
+  const [record] = await ctx.database.get("ggcevo_wish", {
+    handle,
+    wishname: "暴击韵律",
+    startTime: { $lte: /* @__PURE__ */ new Date() },
+    endTime: { $gte: /* @__PURE__ */ new Date() }
+  });
+  return !!record;
+}
+__name(checkCritRhythm, "checkCritRhythm");
+async function calculateTagMultiplier(weaponData, tags, equippedWeapon) {
+  const MOD_EFFECTS = [
+    { mod: "裂甲核心", tag: "重甲", value: 1.5 },
+    { mod: "助燃核心", tag: "惧热", value: 3 },
+    { mod: "助燃核心", tag: "生物", value: 2 },
+    { mod: "金刚石瞄准镜", tag: "重甲", value: 0.8 },
+    { mod: "护盾崩解核心", tag: "护盾", value: 0.8 }
+  ];
+  let totalAdditive = 0;
+  for (const tag of tags) {
+    const activeMod = MOD_EFFECTS.find(
+      (me) => me.tag === tag && equippedWeapon.installedMods?.includes(me.mod)
+    );
+    const effectValue = activeMod ? activeMod.value : weaponData.tagEffects?.[tag] ?? 1;
+    totalAdditive += effectValue - 1;
+  }
+  return totalAdditive;
+}
+__name(calculateTagMultiplier, "calculateTagMultiplier");
+function calculateModifiers(equippedWeapon, weaponName, hasCritRhythm) {
+  let totalModAdd = 0;
+  let hasCrit = false;
+  const modMessages = [];
+  let crystalCrit = 0;
+  let overloadCrit = 0;
+  let rhythmCrit = 0;
+  let weaponCrit = 0;
+  if (weaponName === "MK-4激光步枪") {
+    weaponCrit = 80;
+    modMessages.push(`🔫 【MK-4激光步枪】武器效果：暴击率+${weaponCrit}%`);
   }
-  const radiationResult = BattleEffectProcessor.handleRadiationEffect(targetBoss, weaponName);
-  if (radiationResult) {
-    messages.push(...radiationResult.messages);
-    if (radiationResult.buffMultiplier) {
-      totalBuffMultiplier += radiationResult.buffMultiplier;
+  equippedWeapon.installedMods.forEach((mod) => {
+    if (mod === "动能增幅") {
+      totalModAdd += 0.2;
+      modMessages.push(`🛠️ 【动能增幅】生效：攻击伤害+20%`);
     }
-    if (radiationResult.targetUpdates) {
-      updateStatsByName(radiationResult.targetUpdates.name, radiationResult.targetUpdates.updates);
+    if (mod === "裂甲核心" && weaponName === modConfig[mod].exclusiveTo) {
+      totalModAdd += 0.4;
+      modMessages.push(`🛠️ 【裂甲核心】生效：攻击伤害+40%`);
     }
-    radiationLayerAdded = radiationResult.layerAdded;
-  }
-  const coldResult = BattleEffectProcessor.handleColdEffect(targetBoss, weaponName);
-  if (coldResult) {
-    messages.push(...coldResult.messages);
-    if (coldResult.buffMultiplier) {
-      totalBuffMultiplier += coldResult.buffMultiplier;
+    if (mod === "棱镜水晶") {
+      crystalCrit = 20;
+      modMessages.push(`🛠️ 【棱镜水晶】生效：暴击率+20%`);
     }
-    if (coldResult.targetUpdates) {
-      updateStatsByName(coldResult.targetUpdates.name, coldResult.targetUpdates.updates);
+    if (mod === "棱镜超载核心" && weaponName === modConfig[mod].exclusiveTo) {
+      overloadCrit = 80;
+      modMessages.push(`🛠️ 【棱镜超载核心】生效：暴击率+80%`);
     }
-    coldLayerAdded = coldResult.layerAdded;
+  });
+  rhythmCrit = hasCritRhythm ? 20 : 0;
+  if (hasCritRhythm) {
+    modMessages.push(`🎵 暴击韵律祈愿：暴击率+20%`);
   }
-  const energyDrainResult = BattleEffectProcessor.handleWeaponEnergyDrain(targetBoss, weaponName);
-  if (energyDrainResult) {
-    messages.push(...energyDrainResult.messages);
-    if (energyDrainResult.targetUpdates) {
-      updateStatsByName(energyDrainResult.targetUpdates.name, energyDrainResult.targetUpdates.updates);
-    }
-    energyDrained = energyDrainResult.success || false;
+  const totalCritRate = Math.min(
+    crystalCrit + overloadCrit + rhythmCrit + weaponCrit,
+    // 包含武器专属暴击
+    100
+  );
+  if (totalCritRate > 0) {
   }
-  const layerReduceResult = BattleEffectProcessor.handleWeaponLayerReduction(targetBoss, weaponName);
-  if (layerReduceResult) {
-    messages.push(...layerReduceResult.messages);
-    if (layerReduceResult.targetUpdates) {
-      updateStatsByName(layerReduceResult.targetUpdates.name, layerReduceResult.targetUpdates.updates);
+  if (totalCritRate > 0) {
+    const roll = Math.random() * 100;
+    if (roll <= totalCritRate) {
+      hasCrit = true;
+      totalModAdd += 1;
     }
-    layerReduced = layerReduceResult.reductionSuccess || false;
   }
-  let finalDamage = damage;
-  let adjustedNerfMultiplier = totalNerfMultiplier * (1 - ignoreRate);
-  const damageMultiplier = 1 + totalBuffMultiplier - adjustedNerfMultiplier;
-  finalDamage = Math.max(1, Math.round(damage * damageMultiplier));
-  const frostEvolutionResult = BattleEffectProcessor.handleFrostEvolution(
-    targetBoss,
-    weaponName,
-    finalDamage
-    // 使用最新计算的finalDamage
-  );
-  if (frostEvolutionResult) {
-    messages.push(...frostEvolutionResult.messages);
-    if (frostEvolutionResult.targetUpdates) {
-      updateStatsByName(frostEvolutionResult.targetUpdates.name, frostEvolutionResult.targetUpdates.updates);
-    }
-    if (frostEvolutionResult.isImmune) {
-      immune = true;
-      finalDamage = 0;
-    }
+  return {
+    totalModAdd,
+    hasCrit,
+    modMessages
+    // 返回模块消息数组
+  };
+}
+__name(calculateModifiers, "calculateModifiers");
+async function calculateCareerAdditive(ctx, handle, weaponType, weaponId) {
+  const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
+  let value = 0;
+  let message = "";
+  if (careerData?.career === "警卫长") {
+    value += 0.05;
+    message = "⚔️ 警卫长职业：攻击伤害+5%";
   }
-  const flameAlienResult = BattleEffectProcessor.handleFlameAlien(
-    targetBoss,
-    weaponName,
-    finalDamage
-    // 使用最新计算的finalDamage
-  );
-  if (flameAlienResult) {
-    messages.push(...flameAlienResult.messages);
-    if (flameAlienResult.targetUpdates) {
-      updateStatsByName(flameAlienResult.targetUpdates.name, flameAlienResult.targetUpdates.updates);
+  if (careerData?.career === "武器中士") {
+    value += 0.15;
+    message = "⚔️ 武器中士职业：攻击伤害+15%";
+  }
+  if (careerData?.career === "能量武器专家") {
+    if (weaponType === "能量武器") {
+      value += 0.2;
+      message = "⚔️ 能量武器专家职业：能量武器攻击伤害+20%";
     }
-    if (flameAlienResult.isImmune) {
-      immune = true;
-      finalDamage = 0;
+  }
+  if (careerData?.career === "纵火狂") {
+    if (weaponType === "热能武器") {
+      value += 0.2;
+      message = "⚔️ 纵火狂职业：热能武器攻击伤害+20%";
     }
   }
-  const cosmicEnergyResult = BattleEffectProcessor.handleCosmicEnergy(
-    targetBoss,
-    finalDamage
-    // 使用最新计算的finalDamage
-  );
-  if (cosmicEnergyResult) {
-    messages.push(...cosmicEnergyResult.messages);
-    if (cosmicEnergyResult.targetUpdates) {
-      updateStatsByName(cosmicEnergyResult.targetUpdates.name, cosmicEnergyResult.targetUpdates.updates);
+  if (careerData?.career === "猩红杀手") {
+    if (weaponId === 7) {
+      value += 0.15;
+      message = "⚔️ 猩红杀手职业：侦察步枪攻击伤害+15%";
     }
   }
-  if (immune) {
-    finalDamage = 0;
+  return { value, message };
+}
+__name(calculateCareerAdditive, "calculateCareerAdditive");
+async function calculateWishAdditive(ctx, handle, weapon) {
+  let value = 0;
+  const messages = [];
+  const [sovereign] = await ctx.database.get("ggcevo_wish", {
+    handle,
+    wishname: "王权增幅",
+    startTime: { $lte: /* @__PURE__ */ new Date() },
+    endTime: { $gte: /* @__PURE__ */ new Date() }
+  });
+  if (sovereign) {
+    value += 0.1;
+    messages.push("👑 王权增幅祈愿：攻击伤害+10%");
   }
-  const isLethal = finalDamage >= targetBoss.HP && finalDamage > 0;
-  const survivalSkills = [
-    { func: BattleEffectProcessor.handleSurvivalInstinctI, name: "求生本能I" },
-    { func: BattleEffectProcessor.handleSurvivalInstinctII, name: "求生本能II" },
-    { func: BattleEffectProcessor.handleRevival, name: "复苏" }
-  ];
-  let revivalTriggered = false;
-  if (isLethal) {
-    for (const skill of survivalSkills) {
-      if (targetBoss.skills.includes(skill.name)) {
-        const result = skill.func(targetBoss, finalDamage);
-        if (result) {
-          updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
-          messages.push(...result.messages);
-          revivalTriggered = true;
-          break;
-        }
-      }
-    }
+  const [lament] = await ctx.database.get("ggcevo_wish", {
+    handle,
+    wishname: "悲鸣之锋",
+    startTime: { $lte: /* @__PURE__ */ new Date() },
+    endTime: { $gte: /* @__PURE__ */ new Date() }
+  });
+  if (lament) {
+    const levelBonus = 0.1 * (weapon.level + 1);
+    value += levelBonus;
+    messages.push(`🗡️ 悲鸣之锋祈愿：攻击伤害+${Math.round(levelBonus * 100)}%`);
   }
-  if (!revivalTriggered && !immune && finalDamage > 0) {
-    updateStatsByName(targetBoss.name, {
-      hpChange: -finalDamage
-    });
+  const [critRhythm] = await ctx.database.get("ggcevo_wish", {
+    handle,
+    wishname: "暴击韵律",
+    startTime: { $lte: /* @__PURE__ */ new Date() },
+    endTime: { $gte: /* @__PURE__ */ new Date() }
+  });
+  if (critRhythm) {
+    messages.push("🎵 暴击韵律祈愿：攻击暴击率+20%");
   }
   return {
-    finalDamage,
-    messages,
-    radiationLayerAdded,
-    coldLayerAdded,
-    energyDrained,
-    layerReduced,
-    bileDetonationTrigger
+    value,
+    message: messages.join("，")
   };
 }
-__name(applyPassiveEffects, "applyPassiveEffects");
+__name(calculateWishAdditive, "calculateWishAdditive");
+function calculateRankAdditive(rankRecord) {
+  if (!rankRecord || rankRecord.rank <= 0) return { value: 0, message: "" };
+  const baseValue = Math.floor(rankRecord.rank / 300) * 0.01;
+  const cappedValue = Math.min(baseValue, 1);
+  if (cappedValue > 0) {
+    const percentage = Math.round(cappedValue * 100);
+    return {
+      value: cappedValue,
+      message: `🏆 胜点榜积分加成：攻击伤害+${percentage}%`
+    };
+  }
+  return { value: 0, message: "" };
+}
+__name(calculateRankAdditive, "calculateRankAdditive");
 
 // src/boss/attackhandling.ts
 async function getCleanerRewardBroadcast(ctx, boss, killerHandle, killerName) {
@@ -4815,6 +4832,20 @@ async function handleIgnoreReductionEffects(ctx, handle, weaponName, targetBoss)
   };
 }
 __name(handleIgnoreReductionEffects, "handleIgnoreReductionEffects");
+async function testAttackFunction(ctx, session, handle, config, equippedWeapon, targetBoss, activeBosses, weaponName) {
+  const damageResult = await calculateTotalDamage(ctx, session, config, equippedWeapon, targetBoss);
+  const ignoreReduction = await handleIgnoreReductionEffects(ctx, handle, weaponName, targetBoss);
+  const EffectProcessor = applyPassiveEffects(targetBoss, activeBosses, weaponName, damageResult.damage, ignoreReduction.ignoreRate);
+  const initialDamage = EffectProcessor.finalDamage;
+  return {
+    initialDamage,
+    hasCrit: damageResult.hasCrit,
+    effectMessage: damageResult.effectMessage,
+    passiveMessages: EffectProcessor.messages,
+    ignoreMessage: ignoreReduction.messages
+  };
+}
+__name(testAttackFunction, "testAttackFunction");
 
 // src/index.ts
 var name = "ggcevo-game";
@@ -7470,11 +7501,25 @@ ${validTypes.join("、")}`;
       cleanerRewardBroadcast
     );
   });
-  ctx.command("ggcevo/攻击假人").option("tags", "-t <tags:string> 添加BOSS标签(逗号分隔)").action(async (argv) => {
+  ctx.command("ggcevo/攻击假人").option("tags", "-t <tags:string> 添加BOSS标签(逗号分隔)").option("passives", "-p <passives:string> 添加被动技能(逗号分隔)").option("hp", "-l <hp:number> 模拟假人血量").option("energy", "-e <energy:number> 模拟假人能量").option("skillStacks", "-s <stacks:number> 技能层数").option("radiation", "-r <rad:number> 辐射层数").option("cold", "-c <cold:number> 寒冷层数").option("status", "-a <status:number> 状态层数").action(async (argv) => {
     const session = argv.session;
     const { options } = argv;
+    let hp = 1e4;
+    if (typeof options.hp === "number") {
+      hp = Math.max(1, Math.min(options.hp, 1e4));
+    }
+    let energy = 1e3;
+    if (typeof options.energy === "number") {
+      energy = Math.max(0, Math.min(options.energy, 1e3));
+    }
+    const clampLayer = /* @__PURE__ */ __name((value, max = 100) => typeof value === "number" ? Math.max(0, Math.min(value, max)) : 0, "clampLayer");
+    const skillStacks = clampLayer(options.skillStacks);
+    const radiationLayers = clampLayer(options.radiation);
+    const coldLayers = clampLayer(options.cold);
+    const statusLayers = clampLayer(options.status);
     const parseList = /* @__PURE__ */ __name((str) => str ? str.split(",").map((s) => s.trim()).filter(Boolean) : [], "parseList");
     const tags = parseList(options.tags);
+    const passives = parseList(options.passives);
     const [profile] = await ctx.database.get("sc2arcade_player", { userId: session.userId });
     if (!profile) return "🔒 需要先绑定游戏句柄。";
     const handle = `${profile.regionId}-S2-${profile.realmId}-${profile.profileId}`;
@@ -7487,38 +7532,71 @@ ${validTypes.join("、")}`;
     if (!equippedWeapon) return '请先输入"装备 武器名称"后再测试。';
     const dummyBoss = {
       name: "测试假人",
-      HP: Infinity,
+      HP: hp,
       type: "主宰",
       groupId: 0,
-      tags: tags || []
-      // 从选项获取标签
+      tags: tags || [],
+      skills: passives || [],
+      skillStacks,
+      // 使用自定义技能层数
+      radiationLayers,
+      // 使用自定义辐射层数
+      coldLayers,
+      // 使用自定义寒冷层数
+      energy,
+      isActive: true,
+      statusLayers,
+      // 使用自定义状态层数
+      lastWeaponName: ""
     };
-    const { damage, hasCrit, effectMessage } = await calculateTotalDamage(
-      ctx,
-      session,
-      config,
-      equippedWeapon,
-      dummyBoss,
-      {
-        isTest: true,
-        // 标记为测试模式
-        customTags: tags
-      }
-    );
+    const activeBosses = [dummyBoss];
     const weaponConfigEntry = Object.entries(weaponConfig).find(([_, c]) => c.id === equippedWeapon.weaponId);
     const [weaponName] = weaponConfigEntry;
-    return [
-      `🎯 攻击 ${dummyBoss.name}`,
-      `💥 使用武器：${weaponName}`,
-      options.tags?.length && `🏷️ 模拟标签：${tags.join(", ")}`,
-      ...effectMessage.length ? [
-        "⚡ 攻击效果：",
-        ...effectMessage.map((m) => `▸ ${m}`)
-        // 这里添加符号
-      ] : [],
-      `📊 理论伤害值：${damage}${hasCrit ? " (✨ 暴击)" : ""}`,
-      "💡 提示：添加测试标签: -t 重甲,生物(标签之间用英文逗号分隔)"
-    ].filter((line) => line).join("\n");
+    try {
+      const testResult = await testAttackFunction(
+        ctx,
+        session,
+        handle,
+        config,
+        equippedWeapon,
+        dummyBoss,
+        activeBosses,
+        weaponName
+      );
+      const layerInfo = [];
+      if (skillStacks > 0) layerInfo.push(`技能层数: ${skillStacks}`);
+      if (radiationLayers > 0) layerInfo.push(`辐射层数: ${radiationLayers}`);
+      if (coldLayers > 0) layerInfo.push(`寒冷层数: ${coldLayers}`);
+      if (statusLayers > 0) layerInfo.push(`状态层数: ${statusLayers}`);
+      const layerDisplay = layerInfo.length > 0 ? `📊 层数状态: ${layerInfo.join(" | ")}` : "";
+      return [
+        `🎯 使用武器 ${weaponName} 攻击 ${dummyBoss.name}`,
+        `❤️ 假人血量：${dummyBoss.HP}`,
+        `⚡ 假人能量：${dummyBoss.energy}`,
+        options.tags?.length && `🏷️ 模拟标签：${tags.join(", ")}`,
+        options.passives?.length && `✨ 模拟被动：${passives.join(", ")}`,
+        layerDisplay,
+        // 添加层数显示
+        ...testResult.effectMessage.length > 0 ? [
+          `⚡ 攻击效果：
+${testResult.effectMessage.map((m) => `▸ ${m}`).join("\n")}`
+        ] : [],
+        ...testResult.ignoreMessage.length > 0 ? [
+          `🗡️ 无视减伤效果：
+${testResult.ignoreMessage.map((m) => `▸ ${m}`).join("\n")}`
+        ] : [],
+        ...testResult.passiveMessages.length > 0 ? [
+          `🛡️ 被动效果：
+${testResult.passiveMessages.map((m) => `▸ ${m}`).join("\n")}`
+        ] : [],
+        `📊 理论伤害值：${testResult.initialDamage}${testResult.hasCrit ? "(✨ 暴击)" : ""}`,
+        "💡 提示：可添加标签(-t)、被动(-p)、血量(-l)、能量(-e)",
+        "💡 层数选项：技能层数(-s)、辐射层数(-r)、寒冷层数(-c)、状态层数(-a)",
+        `ℹ️ 测试假人最大血量：10000 | 最大能量：1000 | 最大层数：100`
+      ].filter((line) => line).join("\n");
+    } finally {
+      Object.keys("测试假人").forEach((key) => delete battleStatsMap[key]);
+    }
   });
   ctx.command("ggcevo/伤害榜 [page]", "查看当前主宰伤害排名").usage("输入 伤害榜 [页码] 查看对应页的排行榜，每页10条").action(async (_, page) => {
     const pageNum = parseInt(page) || 1;