koishi-plugin-ggcevo-game 1.4.31 → 1.4.33

package/lib/index.js

@@ -1031,7 +1031,7 @@ var Tasklist = {
     target: 1,
     price: 200,
     redCrystalCost: 0,
-    condition: "使用焚烧枪攻击异形并成功引爆其≥10层的胆汁"
+    condition: "使用焚烧枪攻击目标并成功引爆其≥10层的胆汁"
   },
   "脉冲干扰": {
     id: 4,
@@ -1040,7 +1040,7 @@ var Tasklist = {
     target: 1,
     price: 75,
     redCrystalCost: 0,
-    condition: "使用脉冲扰乱枪攻击异形并成功减少其技能层数"
+    condition: "使用脉冲扰乱枪攻击目标并成功减少其技能层数"
   },
   "弧能消耗": {
     id: 5,
@@ -1049,447 +1049,436 @@ var Tasklist = {
     target: 1,
     price: 75,
     redCrystalCost: 0,
-    condition: "使用弧焊枪攻击异形并成功消耗其能量"
+    condition: "使用弧焊枪攻击目标并成功消耗其能量"
   }
 };
 
 // src/boss/boss.ts
-var asBossTags = /* @__PURE__ */ __name((arr) => arr, "asBossTags");
-var asPassives = /* @__PURE__ */ __name((arr) => arr, "asPassives");
-var defineBoss = /* @__PURE__ */ __name((config) => config, "defineBoss");
 var bossPool = [
-  defineBoss({
+  {
+    id: 1,
     main: {
-      id: 1,
       name: "异齿猛兽首领",
       type: "主宰",
       maxHP: 15e3,
-      energy: 0,
-      tags: asBossTags(["重甲", "生物", "异形"]),
-      passive: asPassives(["异形甲壳"])
+      maxEnergy: 0,
+      tags: ["重甲", "生物", "异形"],
+      passive: ["异形甲壳"]
     },
     minions: [
       {
         name: "异齿猛兽",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "生物", "重型", "异形"]),
-        passive: asPassives(["弱化形态", "异形甲壳"])
+        maxEnergy: 0,
+        tags: ["重甲", "生物", "重型", "异形"],
+        passive: ["弱化形态", "异形甲壳"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 2,
     main: {
-      id: 2,
       name: "寒冰王蛇",
       type: "主宰",
       maxHP: 15e3,
-      energy: 0,
-      tags: asBossTags(["重甲", "生物", "惧热", "重型", "异形"]),
-      passive: asPassives(["冰霜环绕", "冰霜进化"])
+      maxEnergy: 0,
+      tags: ["重甲", "生物", "惧热", "重型", "异形"],
+      passive: ["冰霜环绕", "冰霜进化"]
     },
     minions: [
       {
         name: "冰蛇",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["生物", "惧热", "异形"]),
-        passive: asPassives(["弱化形态", "冰霜回复", "冰霜进化"])
+        maxEnergy: 0,
+        tags: ["生物", "惧热", "异形"],
+        passive: ["弱化形态", "冰霜回复", "冰霜进化"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 3,
     main: {
-      id: 3,
       name: "莽兽",
       type: "主宰",
       maxHP: 12e3,
-      energy: 0,
-      tags: asBossTags(["重甲", "生物", "重型", "异形"]),
-      passive: asPassives(["应激甲壳II", "求生本能II", "冷适应"])
+      maxEnergy: 0,
+      tags: ["重甲", "生物", "重型", "异形"],
+      passive: ["应激甲壳II", "求生本能II", "冷适应"]
     },
     minions: [
       {
         name: "狂暴畸变体",
         type: "子代",
         maxHP: 4e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "生物", "重型", "异形"]),
-        passive: asPassives(["弱化形态", "应激甲壳I", "求生本能I", "冷适应"])
+        maxEnergy: 0,
+        tags: ["重甲", "生物", "重型", "异形"],
+        passive: ["弱化形态", "应激甲壳I", "求生本能I", "冷适应"]
       },
       {
         name: "剧毒畸变体",
         type: "子代",
         maxHP: 4e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "生物", "重型", "异形"]),
-        passive: asPassives(["弱化形态", "应激甲壳I", "求生本能I", "冷适应"])
+        maxEnergy: 0,
+        tags: ["重甲", "生物", "重型", "异形"],
+        passive: ["弱化形态", "应激甲壳I", "求生本能I", "冷适应"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 4,
     main: {
-      id: 4,
       name: "空间站感染虫",
       type: "主宰",
       maxHP: 1e4,
-      energy: 0,
-      tags: asBossTags(["重甲", "生物", "机械", "异形"]),
-      passive: asPassives(["感染空间站", "病毒云", "霉菌滋生"])
+      maxEnergy: 0,
+      tags: ["重甲", "生物", "机械", "异形"],
+      passive: ["感染空间站", "病毒云", "霉菌滋生"]
     },
     minions: [
       {
         name: "机械感染虫",
         type: "子代",
         maxHP: 3e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "生物", "机械", "异形"]),
-        passive: asPassives(["弱化形态", "病毒云", "霉菌滋生"])
+        maxEnergy: 0,
+        tags: ["重甲", "生物", "机械", "异形"],
+        passive: ["弱化形态", "病毒云", "霉菌滋生"]
       },
       {
         name: "空间站哨枪塔",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "机械", "建筑"]),
-        passive: asPassives(["岗哨机枪", "结构装甲"])
+        maxEnergy: 0,
+        tags: ["重甲", "机械", "建筑"],
+        passive: ["岗哨机枪", "结构装甲"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 5,
     main: {
-      id: 5,
       name: "吸血蝙蝠首领",
       type: "主宰",
       maxHP: 12e3,
-      energy: 0,
-      tags: asBossTags(["生物", "异形"]),
-      passive: asPassives(["吸血唾液", "进食", "吐血", "嗜血狂暴"])
+      maxEnergy: 0,
+      tags: ["生物", "异形"],
+      passive: ["吸血唾液", "进食", "吐血", "嗜血狂暴"]
     },
     minions: [
       {
         name: "吸血蝙蝠",
         type: "子代",
         maxHP: 4e3,
-        energy: 0,
-        tags: asBossTags(["生物", "异形"]),
-        passive: asPassives(["弱化形态", "吸血唾液", "进食", "吐血"])
+        maxEnergy: 0,
+        tags: ["生物", "异形"],
+        passive: ["弱化形态", "吸血唾液", "进食", "吐血"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 6,
     main: {
-      id: 6,
       name: "亚电主宰者",
       type: "主宰",
       maxHP: 2e4,
-      energy: 1e3,
-      tags: asBossTags(["护盾", "灵能", "重型", "异形"]),
-      passive: asPassives(["超导体", "能源虹吸", "电能冲击波", "电能立场", "脉冲", "能量黑洞"])
+      maxEnergy: 1e3,
+      tags: ["护盾", "灵能", "重型", "异形"],
+      passive: ["超导体", "能源虹吸", "电能冲击波", "电能立场", "脉冲", "能量黑洞"]
     },
     minions: [
       {
         name: "亚电能者",
         type: "子代",
         maxHP: 6e3,
-        energy: 0,
-        tags: asBossTags(["护盾", "灵能", "异形"]),
-        passive: asPassives(["弱化形态", "超导体", "能量虹吸", "能量黑洞"])
+        maxEnergy: 0,
+        tags: ["护盾", "灵能", "异形"],
+        passive: ["弱化形态", "超导体", "能源虹吸", "能量黑洞"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 7,
     main: {
-      id: 7,
       name: "烈焰庞兽",
       type: "主宰",
       maxHP: 2e4,
-      energy: 0,
-      tags: asBossTags(["重甲", "生物", "惧寒", "重型", "异形"]),
-      passive: asPassives(["火焰异形", "庞兽狂暴", "灼烧粘液", "炼狱爆弹", "火焰吐息", "太阳耀斑"])
+      maxEnergy: 0,
+      tags: ["重甲", "生物", "惧寒", "重型", "异形"],
+      passive: ["火焰异形", "庞兽狂暴", "灼烧粘液", "炼狱爆弹", "火焰吐息", "太阳耀斑"]
     },
     minions: [
       {
         name: "火焰甲虫",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "生物", "惧寒", "异形"]),
-        passive: asPassives(["弱化形态", "火焰异形", "灼烧粘液", "腐蚀胆汁", "燃烧潜地"])
+        maxEnergy: 0,
+        tags: ["重甲", "生物", "惧寒", "异形"],
+        passive: ["弱化形态", "火焰异形", "灼烧粘液", "腐蚀胆汁", "燃烧潜地"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 8,
     main: {
-      id: 8,
       name: "狂猎猛禽首领",
       type: "主宰",
       maxHP: 2e4,
-      energy: 0,
-      tags: asBossTags(["生物", "异形"]),
-      passive: asPassives(["猎手异形", "致命一击", "狂暴", "伪装"])
+      maxEnergy: 0,
+      tags: ["生物", "异形"],
+      passive: ["猎手异形", "致命一击", "狂暴", "伪装"]
     },
     minions: [
       {
         name: "狂猎猛禽1",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["生物", "异形"]),
-        passive: asPassives(["弱化形态", "猎手异形", "狂暴", "伪装"])
+        maxEnergy: 0,
+        tags: ["生物", "异形"],
+        passive: ["弱化形态", "猎手异形", "狂暴", "伪装"]
       },
       {
         name: "狂猎猛禽2",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["生物", "异形"]),
-        passive: asPassives(["弱化形态", "猎手异形", "狂暴", "伪装"])
+        maxEnergy: 0,
+        tags: ["生物", "异形"],
+        passive: ["弱化形态", "猎手异形", "狂暴", "伪装"]
       }
     ]
-  }),
-  defineBoss({
+  },
+  {
+    id: 9,
     main: {
-      id: 9,
       name: "宇宙界主",
       type: "主宰",
       maxHP: 2e4,
-      energy: 1e3,
-      tags: asBossTags(["重甲", "护盾", "生物", "灵能", "异形"]),
-      passive: asPassives(["宇宙能量", "复苏", "光影之刃", "闪电冲锋", "远古预兆", "星界之风", "超视距穿梭"])
+      maxEnergy: 1e3,
+      tags: ["重甲", "护盾", "生物", "灵能", "异形"],
+      passive: ["宇宙能量", "复苏", "光影之刃", "闪电冲锋", "远古预兆", "星界之风", "超视距穿梭"]
     },
     minions: [
       {
         name: "宇宙战将",
         type: "子代",
         maxHP: 5e3,
-        energy: 0,
-        tags: asBossTags(["重甲", "护盾", "生物", "灵能", "异形"]),
-        passive: asPassives(["弱化形态", "心灵狂热", "星界之风"])
+        maxEnergy: 0,
+        tags: ["重甲", "护盾", "生物", "灵能", "异形"],
+        passive: ["弱化形态", "心灵狂热", "星界之风"]
       }
     ]
-  })
+  }
 ];
 
 // src/boss/passive.ts
 var passiveConfig = {
   "弱化形态": {
-    effect: 0.1,
-    description: "子代的防御薄弱，受到的伤害+10%"
+    type: "伤害增减（负面）",
+    description: "子代防御脆弱，所受伤害提升10%"
   },
   "异形甲壳": {
-    effect: -0.2,
-    description: "拥有坚硬的生物甲壳，受到的伤害-20%"
-  },
-  "孤立无援": {
-    effect: 0.2,
-    description: "没有存活的子代，受到的伤害+20%"
+    type: "伤害增减（正面）",
+    description: "强化生物甲壳提供防护，所受伤害降低20%"
   },
   "冰霜回复": {
-    effect: 0,
-    description: "血量降低到30%以下时触发，回复自身40%的最大生命值，并且回复主宰10%的最大生命值(触发后移除)"
+    type: "生存强化（生命回复）",
+    description: "生命值降至30%以下时触发，立即回复自身40%最大生命值，并为其他存活异形回复10%最大生命值（触发后效果移除）"
   },
   "冰霜进化": {
-    effect: 0,
-    description: "免疫冰霜伤害，受到冰霜伤害会回复生命值"
+    type: "状态免疫（寒冷伤害免疫）",
+    description: "免疫寒冷类伤害，受到寒冷伤害时额外回复生命值"
   },
   "冰霜环绕": {
-    effect: 0,
-    description: "血量降低到30%以下时触发，回复自身45%的最大生命值(触发后移除)"
+    type: "生存强化（生命回复+群体增益）",
+    description: "生命值降至30%以下时触发，立即回复自身45%最大生命值，并使所有存活异形获得「寒霜地狱」技能（自身效果触发后移除）"
   },
   "寒霜地狱": {
-    effect: -0.3,
-    description: "灾难的暴风雪降临，受到的伤害-30%"
+    type: "伤害增减（正面）",
+    description: "暴风雪笼罩战场，所受伤害降低30%"
   },
   "应激甲壳I": {
-    effect: -0.2,
-    description: "拥有自适应甲壳，受到的伤害-20%"
+    type: "伤害增减（正面）",
+    description: "基础应激甲壳生效，所受伤害降低20%"
   },
   "应激甲壳II": {
-    effect: -0.25,
-    description: "拥有自适应甲壳，受到的伤害-25%"
+    type: "伤害增减（正面）",
+    description: "进阶应激甲壳生效，所受伤害降低25%"
   },
   "求生本能I": {
-    effect: 0,
-    description: "濒死时，畸变体会迅速回复30%的最大生命值(触发后移除)"
+    type: "生存强化（生命回复）",
+    description: "濒死状态下，快速回复30%最大生命值（触发后效果移除）"
   },
   "求生本能II": {
-    effect: 0,
-    description: "濒死时，畸变体会迅速回复50%的最大生命值(触发后移除)"
+    type: "生存强化（生命回复）",
+    description: "濒死状态下，快速回复50%最大生命值（触发后效果移除）"
   },
   "冷适应": {
-    effect: 0,
-    description: "受到10次寒冷伤害后，自身获得“惧热”标签，并且免疫寒冷伤害"
+    type: "状态免疫（寒冷伤害免疫）",
+    description: "累计承受10次寒冷伤害后，获得「惧热」标签并获得寒冷伤害免疫"
   },
   "感染空间站": {
-    effect: 0,
-    description: "若“空间站哨枪塔”存活，则自身受到的伤害-50%(空间站哨枪塔不属于子代)"
+    type: "伤害增减（正面）",
+    description: "若「空间站哨枪塔」存活，自身所受伤害降低50%"
   },
   "病毒云": {
-    effect: -0.1,
-    description: "释放病毒云雾保护自身，受到的伤害-10%"
+    type: "伤害增减（正面）",
+    description: "释放病毒云雾形成保护，所受伤害降低10%"
   },
   "霉菌滋生": {
-    effect: 0,
-    description: "受到攻击后，若“空间站哨枪塔”存活，则为其回复1%的最大生命值"
+    type: "生存强化（生命回复）",
+    description: "受到攻击后，若「空间站哨枪塔」存活，为其回复1%最大生命值"
   },
   "岗哨机枪": {
-    effect: 0,
-    description: "受到10次攻击后，为存活的异形回复其10%的最大生命值(可重复触发)"
+    type: "生存强化（生命回复）",
+    description: "每累计承受10次攻击后，为所有其他存活异形回复其10%最大生命值"
   },
   "结构装甲": {
-    effect: 0,
-    description: "拥有结构装甲，受到的伤害-20%; 若伤害来源于热能武器，则受到的伤害-40%"
+    type: "伤害增减（正面）",
+    description: "装备结构装甲，常规伤害降低20%；若伤害来源为热能武器，伤害降低提升至40%"
   },
   "吸血唾液": {
-    effect: 0,
-    description: "受到攻击将会获得一层“吸血”，每层“吸血”提供5%的减伤(至多20层)"
+    type: "伤害增减（正面）",
+    description: "受到攻击时叠加「吸血唾液」层数，每层提供5%减伤（最多叠加20层）"
   },
   "进食": {
-    effect: 0,
-    description: "当“吸血”达到20层后，下一次受到攻击将会消耗所有层数回复自身20%的最大生命值"
+    type: "生存强化（生命回复）",
+    description: "当「吸血唾液」层数达到20层时，下一次受击消耗所有层数并回复20%最大生命值"
   },
   "嗜血狂暴": {
-    effect: 0,
-    description: "血量低于50%时，进入狂暴状态，每次受到攻击将会额外获得一层“吸血”，并且受到的伤害-20%"
+    type: "伤害增减（正面）",
+    description: "生命值低于50%时触发狂暴状态，每次受击额外叠加1层「吸血唾液」，同时所受伤害降低20%"
   },
   "吐血": {
-    effect: 0,
-    description: "当无“吸血”层数时，受到的伤害+20%"
-  },
-  "电能导体": {
-    effect: 0,
-    description: "当血量降低到10%以下时，“护盾”标签变为“重甲”标签;"
+    type: "伤害增减（负面）",
+    description: "无「吸血唾液」层数时，所受伤害提升20%"
   },
   "超导体": {
-    effect: 0,
-    description: "当血量降低到5%以下时，“护盾”标签变为“重甲”标签;"
+    type: "状态转换（护盾→重甲）",
+    description: "生命值降至10%以下时，「护盾」标签转换为「重甲」标签"
   },
   "能量虹吸": {
-    effect: 0,
-    description: "当血量≥70%的时候，受到的伤害-40%; 当血量≥30%的时候，受到的伤害-20%"
+    type: "伤害增减（正面）",
+    description: "生命值≥70%时，所受伤害降低40%；生命值≥30%时，伤害降低20%"
   },
   "能源虹吸": {
-    effect: 0,
-    description: "当“能量”≥80%的时候，受到的伤害-50%; 当“能量”≥50%的时候，受到的伤害-30%"
+    type: "伤害增减（正面）",
+    description: "能量值≥80%时，所受伤害降低50%；能量值≥50%时，伤害降低30%"
   },
   "电能立场": {
-    effect: 0,
-    description: "当“能量”≥30%的时候，每次受到攻击有55%的概率免疫此次伤害(无法免疫寒冷伤害); 每拥有一层“寒冷”则降低5%的概率"
+    type: "状态免疫（伤害免疫）",
+    description: "能量值≥30%时，每次受击有55%概率免疫该次伤害（无法免疫寒冷伤害）；每存在1层「寒冷」状态，免疫概率降低5%（至多降低50%）"
   },
   "电能冲击波": {
-    effect: 0,
-    description: "每次受到攻击时，自身回复100点“能量”"
+    type: "生存强化（能量回复）",
+    description: "每次受击时，回复100点「能量」"
   },
   "脉冲": {
-    effect: 0,
-    description: "当“能量”≥30%的时候，每次受到攻击有60%的概率回复所有存活的异形100点血量; 每拥有一层“寒冷”则降低5%的概率"
+    type: "生存强化（生命回复）",
+    description: "能量值≥30%时，每次受击有60%概率为所有存活异形回复100点生命值；每存在1层「寒冷」状态，概率降低5%（至多降低50%）"
   },
   "能量黑洞": {
-    effect: -0.2,
-    description: "存在“能量黑洞”，受到的伤害-20%"
+    type: "伤害增减（正面）",
+    description: "存在「能量黑洞」时，所受伤害降低20%"
   },
   "火焰异形": {
-    effect: 0,
-    description: "免疫火焰伤害，受到火焰伤害时会回复生命值"
+    type: "状态免疫（火焰伤害免疫）",
+    description: "免疫火焰类伤害，受到火焰伤害时额外回复生命值"
   },
   "庞兽狂暴": {
-    effect: 0,
-    description: "血量低于50%时，进入狂暴状态，受到的伤害-50%"
+    type: "伤害增减（正面）",
+    description: "生命值低于50%时触发狂暴状态，所受伤害降低50%"
   },
   "灼烧粘液": {
-    effect: 0,
-    description: "受到伤害时，会获得一层“胆汁”; 若存在“胆汁”层数时受到火焰攻击，将立刻清空层数并回复X点生命值(X为“胆汁”层数 x 10)"
+    type: "生存强化（生命回复）",
+    description: "受到伤害时叠加「灼烧粘液」层数；若存在「灼烧粘液」层数时受到火焰攻击，立即清空层数并回复（层数×10）点生命值"
   },
   "腐蚀胆汁": {
-    effect: 0,
-    description: "当“胆汁”达到10层后，下一次受到攻击将回复所有存活异形1000点血量并清空层数"
+    type: "生存强化（生命回复）",
+    description: "「灼烧粘液」层数达到10层时，下一次受击为所有存活异形回复1000点生命值并清空层数"
   },
   "火焰吐息": {
-    effect: 0,
-    description: "当“胆汁”达到20层后，下一次攻击将回复所有存活异形50%的最大生命值并清空层数"
+    type: "生存强化（生命回复）",
+    description: "「灼烧粘液」层数达到20层时，下一次攻击为所有存活异形回复20%最大生命值并清空层数"
   },
   "太阳耀斑": {
-    effect: 0,
-    description: "当所有子代阵亡后，自身将移除“惧寒”标签和“孤立无援”并且免疫寒冷伤害"
+    type: "状态移除+状态免疫（寒冷伤害免疫）",
+    description: "所有子代阵亡后，移除「惧寒」标签及「孤立无援」并获得寒冷伤害免疫"
   },
   "燃烧潜地": {
-    effect: 0,
-    description: "血量降低到10%以下时触发，回复自身50%的最大生命值(触发后移除)"
+    type: "生存强化（生命回复）",
+    description: "生命值降至10%以下时触发，立即回复50%最大生命值（触发后效果移除）"
   },
   "炼狱爆弹": {
-    effect: 0,
-    description: "每拥有一层“胆汁”，受到的伤害-5%; 若有存活的子代，则每层“胆汁”使受到的伤害额外-5%"
+    type: "伤害增减（正面）",
+    description: "每存在1层「灼烧粘液」，所受伤害降低5%；若存在存活子代，伤害降低效果额外提升5%（即每层「灼烧粘液」总降低10%）"
   },
   "猎手异形": {
-    effect: 0,
-    description: "若有存活的其他异形，则受到的伤害-20%; 若没有存活的其他异形，则受到的伤害+20%; 免疫火焰伤害; 免疫寒冷伤害"
+    type: "伤害增减（条件性）+状态免疫（火焰/寒冷伤害免疫）",
+    description: "存在其他存活异形时，所受伤害降低20%；无其他存活异形时，所受伤害提升20%；免疫火焰及寒冷伤害"
   },
   "狂暴": {
-    effect: 0,
-    description: "血量低于50%时，进入狂暴状态，受到的伤害-50%"
+    type: "伤害增减（正面）",
+    description: "生命值低于50%时触发狂暴状态，所受伤害降低50%"
   },
   "伪装": {
-    effect: 0,
-    description: "受到伤害时，记录伤害来源的武器名称(最多一种，新记录会替换旧记录)，下次受到相同武器伤害时伤害减少80%"
+    type: "伤害增减（正面）",
+    description: "受击时记录伤害来源的武器名称（仅保留最新），下次受到同名称武器伤害时伤害降低80%"
   },
   "致命一击": {
-    effect: 0,
-    description: "受到伤害时，有5%的概率免疫此次伤害"
+    type: "状态免疫（伤害免疫）",
+    description: "受击时有5%概率免疫该次伤害"
   },
   "星界之风": {
-    effect: 0,
-    description: "受到伤害时，有5%的概率回复所有存活异形200点血量"
+    type: "生存强化（生命回复）",
+    description: "受击时有5%概率为所有存活异形回复200点生命值"
   },
   "心灵狂热": {
-    effect: 0,
-    description: "当血量低于50%时，进入心灵狂热状态，受到的伤害-20%，并且触发“星界之风”技能的概率翻倍"
+    type: "伤害增减（正面）",
+    description: "生命值低于50%时进入心灵狂热状态，所受伤害降低20%，同时「星界之风」触发概率翻倍"
   },
   "宇宙能量": {
-    effect: 0,
-    description: "受到攻击时回复与该攻击伤害等额的“能量”; 若“能量”已满，则回复溢出伤害值的血量"
+    type: "生存强化（能量/生命回复）",
+    description: "受击时回复等同于本次伤害值的「能量」；若「能量」已满，则将溢出部分转换为自身生命值"
   },
   "复苏": {
-    effect: 0,
-    description: "受到致命伤害时，免于死亡，快速回复自身50%的最大生命值和100%的“能量”，并且获得“灵能构造炉”技能(触发后移除)"
+    type: "生存强化（生命/能量回复）",
+    description: "承受致命伤害时免疫死亡，立即回复50%最大生命值及100%「能量」，并获得「灵能构造炉」技能（触发后效果移除）"
   },
   "光影之刃": {
-    effect: 0,
-    description: "受到伤害后，获得一层“光影之刃”"
+    type: "状态叠加（层数叠加）",
+    description: "受击后叠加「光影之刃」层数(至多50层)"
   },
   "远古预兆": {
-    effect: 0,
-    description: "受到伤害时，有1%的概率免疫此次伤害并且回复100点“能量”"
+    type: "状态免疫（能量伤害免疫）",
+    description: "受击时有1%概率免疫能量武器伤害并回复100点「能量」"
   },
   "闪电冲锋": {
-    effect: 0,
-    description: "每层“光影之刃”使触发“星界之风”，“远古预兆”和“灵能构造炉”技能的概率+1%"
+    type: "状态增强（触发概率提升）",
+    description: "每存在1层「光影之刃」，「远古预兆」「灵能构造炉」触发概率各提升0.5%"
   },
   "超视距穿梭": {
-    effect: 0,
-    description: "当“能量”≥30%时，每层“光影之刃”使受到的伤害-5%; 当“能量”≥60%时，每层“光影之刃”使受到的伤害-10%; 当“能量”≤10%时，每层“光影之刃”使受到的伤害+5%"
+    type: "伤害增减（条件性）",
+    description: "能量值≥30%时，每层「光影之刃」降低5%所受伤害；能量值≥60%时，每层降低10%；能量值≤10%时，每层提升5%所受伤害"
   },
   "灵能构造炉": {
-    effect: 0,
-    description: "受到攻击后，有1%的概率会随机获得以下4个技能之一(天启超载护盾，塌缩脉冲，地毯式轰炸，轰炸引导)"
+    type: "状态获得（技能获得）",
+    description: "受击后有5%概率随机获得以下技能之一：天启超载护盾、塌缩脉冲、地毯式轰炸、轰炸引导"
   },
   "天启超载护盾": {
-    effect: 0,
-    description: "受到伤害后，有5%的概率回复所有存活异形X点血量(X为“光影之刃”层数 x 10)"
+    type: "生存强化（生命回复）",
+    description: "受击后有5%概率为所有存活异形回复（「光影之刃」层数×10）点生命值"
   },
   "塌缩脉冲": {
-    effect: 0,
-    description: "受到伤害后，额外获得一层“光影之刃”"
+    type: "状态叠加（层数叠加）",
+    description: "受击后额外叠加1层「光影之刃」"
   },
   "地毯式轰炸": {
-    effect: 0,
-    description: "我心中的怒火胜过千万个太阳！移除自身的“孤立无援”，并使受到的伤害-100%"
+    type: "状态移除+伤害增减（正面）",
+    description: "触发时移除「孤立无援」，并使自身所受伤害降低100%"
   },
   "轰炸引导": {
-    effect: 0,
-    description: "受到伤害后，有10%的概率概率回复自身X点“能量”(X为“光影之刃”层数 x 50)"
+    type: "生存强化（能量回复）",
+    description: "受击后有5%概率回复（「光影之刃」层数×50）点「能量」"
   }
 };
 
@@ -1880,14 +1869,17 @@ function createHpBar(current, max) {
 }
 __name(createHpBar, "createHpBar");
 async function activateNextBossGroup(ctx, currentBossId = null) {
-  let nextIndex = 0;
-  if (currentBossId !== null) {
-    const currentIndex = bossPool.findIndex((b) => b.main.id === currentBossId);
-    if (currentIndex !== -1) {
-      nextIndex = (currentIndex + 1) % bossPool.length;
+  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 nextBossGroup = bossPool[nextIndex];
+  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,
@@ -1895,8 +1887,8 @@ async function activateNextBossGroup(ctx, currentBossId = null) {
     tags: nextBossGroup.main.tags,
     // 新增标签字段
     skills: [...nextBossGroup.main.passive],
-    energy: nextBossGroup.main.energy,
-    groupId: nextBossGroup.main.id,
+    energy: nextBossGroup.main.maxEnergy,
+    groupId: nextBossGroup.id,
     isActive: true,
     respawnTime: /* @__PURE__ */ new Date()
   });
@@ -1908,8 +1900,8 @@ async function activateNextBossGroup(ctx, currentBossId = null) {
       tags: minion.tags,
       // 新增标签字段
       skills: [...minion.passive],
-      energy: minion.energy,
-      groupId: mainBoss.groupId,
+      energy: minion.maxEnergy,
+      groupId: nextBossGroup.id,
       isActive: true,
       respawnTime: /* @__PURE__ */ new Date()
     });
@@ -2021,7 +2013,7 @@ async function applyItemEffect(ctx, session, handle, itemConfig2, target) {
           message: `目标${target}拥有"${targetboss.tags.includes("建筑") ? "建筑" : "重型"}"标签，无法使用此物品。`
         };
       }
-      const currentCount = targetboss.Skillcountpoints || 0;
+      const currentCount = targetboss?.skillStacks || 0;
       if (currentCount <= 0) {
         return {
           success: false,
@@ -2033,7 +2025,7 @@ async function applyItemEffect(ctx, session, handle, itemConfig2, target) {
       await ctx.database.set(
         "ggcevo_boss",
         { name: target },
-        { Skillcountpoints: newCount }
+        { skillStacks: newCount }
       );
       return {
         success: true,
@@ -2385,1866 +2377,1870 @@ async function getRankInfo(ctx, config, handle) {
 }
 __name(getRankInfo, "getRankInfo");
 
-// src/boss/passivehandler.ts
-var PassiveHandler = {
-  // 冰霜进化处理（免疫冰霜伤害）
-  handleFrostEvolution: /* @__PURE__ */ __name(function(targetBoss, weaponName, damage, maxHP) {
-    if (targetBoss.skills.includes("冰霜进化") && weaponName === "零度之下") {
-      const healAmount = damage;
+// src/boss/BattleEffectProcessor.ts
+var battleStatsMap = {};
+function updateStatsByName(name2, updates) {
+  const existing = battleStatsMap[name2] ?? {
+    name: name2,
+    // 键与 name 一致
+    hpChange: 0,
+    energyChange: 0,
+    tagsAdded: [],
+    tagsRemoved: [],
+    skillsAdded: [],
+    skillsRemoved: [],
+    skillStacksChanged: 0,
+    statusLayersChanged: 0,
+    radiationLayersChange: 0,
+    coldLayersChange: 0,
+    lastWeaponName: ""
+  };
+  battleStatsMap[name2] = {
+    // name 不可变（保持原键）
+    name: existing.name,
+    // 数值类型：累加（支持正负变化）
+    hpChange: existing.hpChange + (updates.hpChange ?? 0),
+    energyChange: existing.energyChange + (updates.energyChange ?? 0),
+    skillStacksChanged: existing.skillStacksChanged + (updates.skillStacksChanged ?? 0),
+    statusLayersChanged: existing.statusLayersChanged + (updates.statusLayersChanged ?? 0),
+    radiationLayersChange: existing.radiationLayersChange + (updates.radiationLayersChange ?? 0),
+    coldLayersChange: existing.coldLayersChange + (updates.coldLayersChange ?? 0),
+    // 数组类型：合并（新增内容追加到现有数组）
+    tagsAdded: [...existing.tagsAdded, ...updates.tagsAdded ?? []],
+    tagsRemoved: [...existing.tagsRemoved, ...updates.tagsRemoved ?? []],
+    skillsAdded: [...existing.skillsAdded, ...updates.skillsAdded ?? []],
+    skillsRemoved: [...existing.skillsRemoved, ...updates.skillsRemoved ?? []],
+    // 字符串类型：覆盖（取最新值）
+    lastWeaponName: updates.lastWeaponName ?? existing.lastWeaponName
+  };
+}
+__name(updateStatsByName, "updateStatsByName");
+function getMaxHPByName(bossName) {
+  for (const boss of bossPool) {
+    if (boss.main.name === bossName) {
+      return boss.main.maxHP;
+    }
+    for (const minion of boss.minions) {
+      if (minion.name === bossName) {
+        return minion.maxHP;
+      }
+    }
+  }
+  return void 0;
+}
+__name(getMaxHPByName, "getMaxHPByName");
+function getMaxEnergyByName(bossName) {
+  for (const boss of bossPool) {
+    if (boss.main.name === bossName) {
+      return boss.main.maxEnergy;
+    }
+    for (const minion of boss.minions) {
+      if (minion.name === bossName) {
+        return minion.maxEnergy;
+      }
+    }
+  }
+  return void 0;
+}
+__name(getMaxEnergyByName, "getMaxEnergyByName");
+var BattleEffectProcessor = {
+  // 弱化形态
+  handleWeakForm: /* @__PURE__ */ __name(function(targetBoss) {
+    if (targetBoss.skills.includes("弱化形态")) {
+      const newBuffMultiplier = 0.1;
+      const messages = [`📚 【弱化形态】生效：子代防御脆弱，所受伤害提升10%`];
       return {
-        updatedHP: Math.min(targetBoss.HP + healAmount, maxHP),
-        initialDamage: 0,
-        // 直接设置伤害为0
-        messages: [`❄️ 【冰霜进化】生效：免疫寒冷伤害，${targetBoss.name}回复${healAmount}生命值`]
+        buffMultiplier: newBuffMultiplier,
+        messages
       };
     }
     return null;
-  }, "handleFrostEvolution"),
-  // 冰霜环绕处理（主宰专用）
-  handleFrostSurround: /* @__PURE__ */ __name(async (ctx, targetBoss, currentHP, maxHP) => {
-    if (!targetBoss.skills.includes("冰霜环绕") || currentHP <= 0 || // 新增血量必须大于0的判断
-    currentHP / maxHP > 0.3) {
+  }, "handleWeakForm"),
+  // 异形甲壳
+  handleAlienShell: /* @__PURE__ */ __name(function(targetBoss) {
+    if (targetBoss.skills.includes("异形甲壳")) {
+      const newNerfMultiplier = 0.2;
+      const messages = [`🛡️ 【异形甲壳】生效：强化生物甲壳提供防护，所受伤害降低20%`];
+      return {
+        nerfMultiplier: newNerfMultiplier,
+        messages
+      };
+    }
+    return null;
+  }, "handleAlienShell"),
+  // 孤立无援处理（活跃Boss中仅自己时增伤20%）
+  handleIsolated: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const isIsolated = activeBosses.length === 1 && // 活跃Boss仅1个
+    activeBosses[0].name === targetBoss.name;
+    if (isIsolated) {
+      const newBuffMultiplier = 0.2;
+      const messages = [
+        `🌌 【孤立无援】生效：无存活子代时，所受伤害提升20%`
+      ];
+      return {
+        buffMultiplier: newBuffMultiplier,
+        messages
+      };
+    }
+    return null;
+  }, "handleIsolated"),
+  handleFrostRegeneration: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("冰霜回复")) {
+      return null;
+    }
+    const targetMaxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    if (currentHP > targetMaxHP * 0.3) {
       return null;
     }
-    const healAmount = Math.floor(maxHP * 0.45);
-    const updatedHP = Math.min(currentHP + healAmount, maxHP);
-    const activeMinions = await ctx.database.get("ggcevo_boss", {
-      groupId: targetBoss.groupId,
-      type: "子代",
-      isActive: true
+    const selfHealAmount = Math.round(targetMaxHP * 0.4);
+    const targetUpdates = {
+      hpChange: selfHealAmount,
+      // 累加HP变化量（正数回复）
+      skillsRemoved: ["冰霜回复"]
+      // 移除技能
+    };
+    messages.push(`❄️ 【冰霜回复】生效：自身回复${selfHealAmount}点生命值`);
+    const otherSurvivingBosses = activeBosses.filter(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
+    );
+    otherSurvivingBosses.forEach((otherBoss) => {
+      const otherName = otherBoss.name;
+      const otherMaxHP = getMaxHPByName(otherName);
+      const otherHealAmount = Math.round(otherMaxHP * 0.1);
+      otherUpdates.push({
+        name: otherName,
+        updates: { hpChange: otherHealAmount }
+      });
+      messages.push(`❄️ 「${otherName}」回复${otherHealAmount}点生命值`);
     });
-    const skillUpdates = [
-      {
+    messages.push(`❄️ 【冰霜回复】触发后技能移除`);
+    return {
+      messages,
+      targetUpdates: {
         name: targetBoss.name,
-        remove: ["冰霜环绕"],
-        add: ["寒霜地狱"]
+        updates: targetUpdates
       },
-      ...activeMinions.map((m) => ({
-        name: m.name,
-        add: ["寒霜地狱"]
-      }))
-    ];
-    return {
-      updatedHP,
-      skillUpdates,
-      messages: [
-        `❄️ 【冰霜环绕】生效，${targetBoss.name}回复45%最大生命值(+${healAmount}HP)`,
-        `🌪️ 警告！【寒霜地狱】降临，所有存活的异形获得30%减伤效果`
-      ]
+      otherUpdates
     };
-  }, "handleFrostSurround"),
-  // 冰霜回复处理（子代专用）
-  handleFrostRecovery: /* @__PURE__ */ __name(async (ctx, targetBoss, currentHP, maxHP, activeBosses, bossGroup) => {
-    if (!targetBoss.skills.includes("冰霜回复") || currentHP <= 0 || // 新增血量必须大于0的判断
-    currentHP / maxHP > 0.3) {
+  }, "handleFrostRegeneration"),
+  handleFrostAura: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("冰霜环绕")) {
+      return null;
+    }
+    const targetMaxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    const triggerCondition = currentHP <= targetMaxHP * 0.3;
+    if (!triggerCondition) {
       return null;
     }
-    const selfHeal = Math.floor(maxHP * 0.4);
-    const updatedHP = Math.min(currentHP + selfHeal, maxHP);
-    let mainHeal = 0;
-    const mainBoss = activeBosses.find(
-      (b) => b.groupId === targetBoss.groupId && b.type === "主宰"
+    const selfHealAmount = Math.round(targetMaxHP * 0.45);
+    const targetUpdates = {
+      hpChange: selfHealAmount,
+      // 累加HP变化量（正数回复）
+      skillsRemoved: ["冰霜环绕"],
+      // 移除自身原有技能
+      skillsAdded: ["寒霜地狱"]
+      // 新增【寒霜地狱】技能（自身）
+    };
+    messages.push(`❄️ 【冰霜环绕】生效：自身回复${selfHealAmount}点生命值`);
+    messages.push(`❄️ 「${targetBoss.name}」获得【寒霜地狱】技能`);
+    const survivingMinions = activeBosses.filter(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
     );
-    if (mainBoss) {
-      const mainMaxHP = bossGroup.main.maxHP;
-      mainHeal = Math.floor(mainMaxHP * 0.1);
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: mainBoss.name },
-        { HP: Math.min(mainBoss.HP + mainHeal, mainMaxHP) }
-      );
+    if (survivingMinions.length > 0) {
+      survivingMinions.forEach((minion) => {
+        const minionName = minion.name;
+        const minionUpdates = {
+          skillsAdded: ["寒霜地狱"]
+          // 新增【寒霜地狱】技能（仅异形）
+        };
+        otherUpdates.push({
+          name: minionName,
+          updates: minionUpdates
+        });
+        messages.push(`❄️ 「${minionName}」获得【寒霜地狱】技能`);
+      });
     }
+    messages.push(`❄️ 【冰霜环绕】触发后技能移除`);
     return {
-      updatedHP,
-      skillUpdates: [{
+      messages,
+      targetUpdates: {
         name: targetBoss.name,
-        remove: ["冰霜回复"]
-      }],
-      messages: [
-        `❄️ 【冰霜回复】生效，${targetBoss.name}回复40%最大生命值(+${selfHeal}HP)，${mainBoss.name}回复10%最大生命值(+${mainHeal}HP)`
-      ]
+        updates: targetUpdates
+      },
+      otherUpdates
     };
-  }, "handleFrostRecovery"),
-  // 冷适应计数处理
-  handleColdAdaptation: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName) {
-    if (weaponName !== "零度之下" || !targetBoss.skills.includes("冷适应") || targetBoss.tags.includes("惧热")) {
+  }, "handleFrostAura"),
+  // 冰霜进化处理（免疫伤害并回复生命值）
+  handleFrostEvolution: /* @__PURE__ */ __name(function(targetBoss, weaponName, damage) {
+    const messages = [];
+    let isImmune = false;
+    if (!targetBoss.skills.includes("冰霜进化")) {
       return null;
     }
-    const newCount = (targetBoss.Skillcountpoints || 0) + 1;
-    await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, {
-      Skillcountpoints: newCount
-    });
-    if (newCount >= 10 && !targetBoss.tags.includes("惧热")) {
-      const newtags = [.../* @__PURE__ */ new Set([...targetBoss.tags, "惧热"])];
-      await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, {
-        tags: newtags
-      });
+    const isColdWeapon = weaponName === "零度之下";
+    if (!isColdWeapon) {
+      return null;
+    }
+    isImmune = true;
+    const healAmount = damage;
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        hpChange: healAmount
+        // 生命值变化量
+      }
+    };
+    messages.push(`❄️ 【冰霜进化】生效：「${targetBoss.name}」免疫寒冷伤害`);
+    messages.push(`❄️ 恢复${healAmount}点生命值`);
+    return {
+      isImmune,
+      messages,
+      targetUpdates
+    };
+  }, "handleFrostEvolution"),
+  // 寒霜地狱处理
+  handleFrostHell: /* @__PURE__ */ __name(function(targetBoss) {
+    if (targetBoss.skills.includes("寒霜地狱")) {
+      const newNerfMultiplier = 0.3;
+      const messages = [`❄️ 【寒霜地狱】生效：暴风雪笼罩战场，所受伤害降低30%`];
       return {
-        messages: [`❄️ 【冷适应】生效，${targetBoss.name}获得「惧热」标签`]
+        nerfMultiplier: newNerfMultiplier,
+        messages
       };
     }
     return null;
-  }, "handleColdAdaptation"),
-  // 冷适应免疫处理
-  handleColdAdaptationImmunity: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
-    if (targetBoss.skills.includes("冷适应") && targetBoss.Skillcountpoints >= 10 && weaponName === "零度之下") {
+  }, "handleFrostHell"),
+  // 应激甲壳I处理（基础减伤20%）
+  handleStressShellI: /* @__PURE__ */ __name(function(targetBoss) {
+    if (targetBoss.skills.includes("应激甲壳I")) {
+      const newNerfMultiplier = 0.2;
+      const messages = [`🛡️ 【应激甲壳I】生效：基础应激甲壳生效，所受伤害降低20%`];
       return {
-        initialDamage: 0,
-        // 直接设置伤害为0
-        messages: [`❄️ 【冷适应】生效：免疫寒冷伤害`]
+        nerfMultiplier: newNerfMultiplier,
+        messages
       };
     }
     return null;
-  }, "handleColdAdaptationImmunity"),
-  // 求生本能处理
-  handleSurvivalInstinct: /* @__PURE__ */ __name(function(targetBoss, currentHP, maxHP) {
-    if (currentHP > 0) return null;
-    let effect = null;
-    if (targetBoss.skills.includes("求生本能I")) {
-      effect = { heal: maxHP * 0.3, skill: "求生本能I" };
-    } else if (targetBoss.skills.includes("求生本能II")) {
-      effect = { heal: maxHP * 0.5, skill: "求生本能II" };
-    }
-    if (!effect) return null;
-    return {
-      updatedHP: effect.heal,
-      messages: [`【${effect.skill}】生效，${targetBoss.name}濒死时瞬间回复${effect.heal}生命值`],
-      skillUpdates: [{
-        name: targetBoss.name,
-        remove: [effect.skill]
-      }]
-    };
-  }, "handleSurvivalInstinct"),
-  // 感染空间站处理（返回减伤系数）
-  handleInfectedStation: /* @__PURE__ */ __name(async (ctx, targetBoss) => {
-    if (targetBoss.name !== "空间站感染虫" || !targetBoss.skills.includes("感染空间站")) return null;
-    const [sentryGun] = await ctx.database.get("ggcevo_boss", { name: "空间站哨枪塔", isActive: true });
-    if (sentryGun) {
+  }, "handleStressShellI"),
+  // 应激甲壳II处理（进阶减伤25%）
+  handleStressShellII: /* @__PURE__ */ __name(function(targetBoss) {
+    if (targetBoss.skills.includes("应激甲壳II")) {
+      const newNerfMultiplier = 0.25;
+      const messages = [`🛡️ 【应激甲壳II】生效：进阶应激甲壳生效，所受伤害降低25%`];
       return {
-        damageMultiplier: -0.5,
-        // 50% 减伤
-        messages: ["🛡️ 【感染空间站】生效：空间站哨枪塔存活时，受到的伤害-50%"]
+        nerfMultiplier: newNerfMultiplier,
+        messages
       };
     }
     return null;
-  }, "handleInfectedStation"),
-  // 霉菌滋生处理
-  handleMoldGrowth: /* @__PURE__ */ __name(async (ctx, targetBoss, bossGroup) => {
-    if (!targetBoss.skills.includes("霉菌滋生")) {
+  }, "handleStressShellII"),
+  handleSurvivalInstinctI: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("求生本能I")) {
       return null;
     }
-    const sentryConfig = bossGroup.minions.find((m) => m.name === "空间站哨枪塔");
-    if (!sentryConfig) return null;
-    const [sentryGun] = await ctx.database.get("ggcevo_boss", {
-      name: "空间站哨枪塔",
-      isActive: true
-    });
-    if (sentryGun) {
-      const healAmount = Math.floor(sentryConfig.maxHP * 0.01);
-      const newHP = Math.min(sentryGun.HP + healAmount, sentryConfig.maxHP);
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: "空间站哨枪塔" },
-        { HP: newHP }
-      );
-      return {
-        messages: [`🦠 【霉菌滋生】生效：空间站哨枪塔回复1%最大生命值(+${healAmount}HP)`]
-      };
-    }
-    return null;
-  }, "handleMoldGrowth"),
-  // 岗哨机枪处理
-  handleSentryGun: /* @__PURE__ */ __name(async (ctx, targetBoss, bossGroup) => {
-    if (!targetBoss.skills.includes("岗哨机枪")) {
+    const targetMaxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    if (currentHP !== 0) {
       return null;
     }
-    const currentCount = targetBoss.Skillcountpoints || 0;
-    const updates = [];
-    let messages = [];
-    if (currentCount === 10) {
-      const getMaxHP = /* @__PURE__ */ __name((name2) => {
-        if (name2 === "空间站感染虫") return bossGroup.main.maxHP;
-        const minion = bossGroup.minions.find((m) => m.name === name2);
-        return minion?.maxHP || 0;
-      }, "getMaxHP");
-      const [infectionBug] = await ctx.database.get("ggcevo_boss", {
-        name: "空间站感染虫",
-        isActive: true
-      });
-      if (infectionBug) {
-        const maxHP = getMaxHP("空间站感染虫");
-        const heal = Math.floor(maxHP * 0.1);
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: infectionBug.name },
-            { HP: Math.min(infectionBug.HP + heal, maxHP) }
-          )
-        );
-        messages.push(`空间站感染虫回复${heal}HP`);
+    const selfHealAmount = Math.round(targetMaxHP * 0.3);
+    const updates = {
+      hpChange: selfHealAmount,
+      skillsRemoved: ["求生本能I"]
+    };
+    messages.push(`❤️ 【求生本能I】生效：生命值归零时回复${selfHealAmount}点生命值`);
+    messages.push(`❤️ 「${targetBoss.name}」的【求生本能I】技能已移除`);
+    return {
+      messages,
+      targetUpdates: {
+        name: targetBoss.name,
+        updates
       }
-      const [mechaBug] = await ctx.database.get("ggcevo_boss", {
-        name: "机械感染虫",
-        isActive: true
-      });
-      if (mechaBug) {
-        const maxHP = getMaxHP("机械感染虫");
-        const heal = Math.floor(maxHP * 0.1);
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: mechaBug.name },
-            { HP: Math.min(mechaBug.HP + heal, maxHP) }
-          )
-        );
-        messages.push(`机械感染虫回复${heal}HP`);
-      }
-      updates.push(
-        ctx.database.set(
-          "ggcevo_boss",
-          { name: targetBoss.name },
-          { Skillcountpoints: 0 }
-        )
-      );
-      await Promise.all(updates);
-      return {
-        messages: ["🔫 【岗哨机枪】生效：" + messages.join("，")]
-      };
-    }
-    const newCount = currentCount + 1;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: newCount }
-    );
-    if (newCount === 10) {
-      return {
-        messages: ["🔫 【岗哨机枪】达到10层！下次攻击将清空层数并治疗所有存活的异形"]
-      };
+    };
+  }, "handleSurvivalInstinctI"),
+  handleSurvivalInstinctII: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("求生本能II")) {
+      return null;
     }
-    return null;
-  }, "handleSentryGun"),
-  // 结构装甲处理（返回减伤系数）
-  handleStructuralArmor: /* @__PURE__ */ __name((targetBoss, weaponData) => {
-    if (!targetBoss.skills.includes("结构装甲")) return null;
-    let reduction = 0.2;
-    let msg = "受到常规武器伤害-20%";
-    if (weaponData.type === "热能武器") {
-      reduction = 0.4;
-      msg = "受到热能武器伤害-40%";
+    const targetMaxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    if (currentHP !== 0) {
+      return null;
     }
+    const selfHealAmount = Math.round(targetMaxHP * 0.5);
+    const updates = {
+      hpChange: selfHealAmount,
+      // 生命值变化量
+      skillsRemoved: ["求生本能II"]
+      // 移除的技能
+    };
+    messages.push(`❤️ 【求生本能II】生效：生命值归零时回复${selfHealAmount}点生命值`);
+    messages.push(`❤️ 「${targetBoss.name}」的【求生本能II】技能已移除`);
     return {
-      damageMultiplier: -reduction,
-      // 返回减伤系数
-      messages: [`🛡️ 【结构装甲】生效：${msg}`]
+      messages,
+      targetUpdates: {
+        name: targetBoss.name,
+        updates
+      }
     };
-  }, "handleStructuralArmor"),
-  // 修改 handleBloodEffects 函数
-  handleBloodEffects: /* @__PURE__ */ __name(function(targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("吸血唾液")) return null;
-    const bloodStacks = targetBoss.Skillcountpoints || 0;
-    let buffAmount = 0;
-    let nerfAmount = 0;
+  }, "handleSurvivalInstinctII"),
+  // 在 PassiveHandler 对象中添加冷适应技能的处理函数
+  handleColdAdaptation: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
     const messages = [];
-    if (bloodStacks > 0) {
-      const reduction = bloodStacks * 0.05;
-      nerfAmount += reduction;
-      messages.push(`🩸 【吸血唾液】生效：受到的伤害-${(reduction * 100).toFixed(0)}%`);
-    }
-    if (targetBoss.skills.includes("嗜血狂暴") && currentHP / maxHP < 0.5) {
-      nerfAmount += 0.2;
-      messages.push(`🔥 【嗜血狂暴】生效：进入狂暴状态，受到的伤害-20%`);
-    }
-    if (targetBoss.skills.includes("吐血") && bloodStacks < 1) {
-      buffAmount += 0.2;
-      messages.push(`💔 【吐血】生效：无"吸血"层数，受到的伤害+20%`);
+    let isImmune = false;
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("冷适应")) {
+      return null;
     }
-    if (buffAmount > 0 || nerfAmount > 0) {
+    const currentLayers = targetBoss.statusLayers || 0;
+    const hasFearHeatTag = targetBoss.tags.includes("惧热") || false;
+    if (hasFearHeatTag && weaponName === "零度之下") {
+      isImmune = true;
+      messages.push(`🧊 【冷适应】生效：免疫寒冷伤害`);
       return {
-        buffAmount,
-        // 正值增伤系数
-        nerfAmount,
-        // 正值减伤系数
-        messages
+        isImmune,
+        messages,
+        targetUpdates
       };
     }
-    return null;
-  }, "handleBloodEffects"),
-  handleBloodCount: /* @__PURE__ */ __name(async function(ctx, targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("吸血唾液")) {
-      return null;
+    if (currentLayers < 10) {
+      const newLayers = currentLayers + 1;
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          statusLayersChanged: 1
+          // 层数+1
+        }
+      };
+      messages.push(`❄️ 【冷适应】叠加状态：当前累计${newLayers}/10次寒冷伤害`);
+      if (newLayers >= 10) {
+        targetUpdates.updates.tagsAdded = ["惧热"];
+        messages.push(`🧊 【冷适应】触发：累计承受10次寒冷伤害，获得「惧热」标签`);
+        messages.push(`🧊 【冷适应】获得永久免疫寒冷伤害效果`);
+      }
     }
-    let messages = [];
-    let updatedHP = currentHP;
-    let newStacks;
-    const oldStacks = targetBoss.Skillcountpoints || 0;
-    if (oldStacks >= 20 && targetBoss.skills.includes("进食")) {
-      const heal = Math.floor(maxHP * 0.2);
-      updatedHP = Math.min(currentHP + heal, maxHP);
-      await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, { Skillcountpoints: 0 });
-      messages.push(`🍽️ 【进食】生效：${targetBoss.name}回复20%最大生命值(+${heal}HP)，“吸血”层数清零`);
-      return { updatedHP, messages };
-    }
-    if (targetBoss.skills.includes("吸血唾液")) {
-      newStacks = oldStacks + 1;
-      messages.push(`🩸 【吸血唾液】生效：获得1层“吸血”`);
-    }
-    if (targetBoss.skills.includes("嗜血狂暴") && currentHP / maxHP < 0.5) {
-      newStacks += 1;
-      messages.push(`🔥 【嗜血狂暴】生效：额外获得1层“吸血”`);
-    }
-    newStacks = Math.min(newStacks, 20);
-    if (oldStacks < 20 && newStacks >= 20) {
-      messages.push(`🩸 “吸血”达到${newStacks}层，下次受到攻击将触发【进食】`);
-    }
-    await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, { Skillcountpoints: newStacks });
-    return { updatedHP, messages };
-  }, "handleBloodCount"),
-  // 修改后的伽马枪辐射处理（无限叠层，每层2.5%增伤，有效上限20层）
-  handleGammaRadiation: /* @__PURE__ */ __name(async (ctx, targetBoss, weaponName) => {
-    if (weaponName !== "伽马枪" || targetBoss.tags.includes("机械") || !targetBoss.tags.includes("生物")) {
+    return {
+      isImmune,
+      messages,
+      targetUpdates
+    };
+  }, "handleColdAdaptation"),
+  // 感染空间站处理（空间站存活时自身减伤50%）
+  handleInfectedSpaceStation: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    if (!targetBoss.skills.includes("感染空间站")) {
       return null;
     }
-    const messages = [];
-    let radiationApplied = false;
-    const currentLayers = targetBoss.Vulnerability || 0;
-    const newLayers = currentLayers + 1;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Vulnerability: newLayers }
+    const spaceStation = activeBosses.find(
+      (boss) => boss.name === "空间站哨枪塔" && boss.isActive
     );
-    messages.push(`☢️ ${targetBoss.name}获得1层“辐射”`);
-    radiationApplied = true;
+    if (!spaceStation) {
+      return null;
+    }
+    const newNerfMultiplier = 0.5;
+    messages.push(`🛸 【感染空间站】生效：因「空间站哨枪塔」存活，自身所受伤害降低50%`);
     return {
-      messages,
-      radiationApplied
+      nerfMultiplier: newNerfMultiplier,
+      // 返回调整后的减伤系数
+      messages
     };
-  }, "handleGammaRadiation"),
-  // 修改后的辐射伤害计算（每层2.5%增伤，上限20层）
-  calculateRadiationDamage: /* @__PURE__ */ __name((targetBoss) => {
-    const radiationLayers = targetBoss.Vulnerability || 0;
-    if (radiationLayers < 1) return null;
-    const effectiveLayers = Math.min(radiationLayers, 20);
-    const damageIncrease = effectiveLayers * 2.5;
-    const maxIncrease = 50;
+  }, "handleInfectedSpaceStation"),
+  // 病毒云处理（释放病毒云雾减伤10%）
+  handleVirusCloud: /* @__PURE__ */ __name(function(targetBoss) {
     const messages = [];
-    let statusMsg = `☢️ 【辐射】生效：当前${radiationLayers}层“辐射”`;
-    statusMsg += `，受到的伤害+${damageIncrease}%`;
-    if (damageIncrease >= maxIncrease) {
-      statusMsg += ``;
+    if (!targetBoss.skills.includes("病毒云")) {
+      return null;
     }
-    messages.push(statusMsg);
+    const newNerfMultiplier = 0.1;
+    messages.push(`☁️ 【病毒云】生效：释放病毒云雾形成保护，所受伤害降低10%`);
     return {
-      damageMultiplier: effectiveLayers * 0.025,
-      // 每层2.5%增伤
+      nerfMultiplier: newNerfMultiplier,
+      // 返回调整后的减伤系数
       messages
     };
-  }, "calculateRadiationDamage"),
-  // 修改后的寒冷处理（无限叠层，每层2.5%增伤，有效上限20层）
-  handleColdEffect: /* @__PURE__ */ __name(async (ctx, targetBoss, weaponName) => {
-    if (weaponName !== "零度之下") {
+  }, "handleVirusCloud"),
+  // 霉菌滋生处理（空间站存活时为其回复1%最大生命值）
+  handleMoldGrowth: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    if (!targetBoss.skills.includes("霉菌滋生")) {
       return null;
     }
-    const messages = [];
-    let freezing = false;
-    const currentFreezing = targetBoss.freezing || 0;
-    const newFreezing = currentFreezing + 1;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { freezing: newFreezing }
+    const spaceStation = activeBosses.find(
+      (boss) => boss.name === "空间站哨枪塔" && boss.isActive
     );
-    messages.push(`❄️ ${targetBoss.name} 获得1层“寒冷”`);
-    freezing = true;
+    if (!spaceStation) {
+      return null;
+    }
+    const spaceStationMaxHP = getMaxHPByName(spaceStation.name);
+    const healAmount = Math.round(spaceStationMaxHP * 0.01);
+    const spaceStationUpdates = {
+      name: spaceStation.name,
+      updates: {
+        hpChange: healAmount
+      }
+    };
+    messages.push(`🍄 【霉菌滋生】生效：为空间站哨枪塔回复${healAmount}点生命值`);
     return {
       messages,
-      freezing
+      spaceStationUpdates
     };
-  }, "handleColdEffect"),
-  // 修改后的寒冷伤害计算（每层2.5%增伤，上限20层）
-  calculateColdDamage: /* @__PURE__ */ __name((targetBoss) => {
-    const freezingLayers = targetBoss.freezing || 0;
-    if (freezingLayers < 1) return null;
-    const effectiveLayers = Math.min(freezingLayers, 20);
-    const damageIncrease = effectiveLayers * 2.5;
-    const maxIncrease = 50;
+  }, "handleMoldGrowth"),
+  // 岗哨机枪处理（累计10次攻击后为其他异形回复10%最大生命值）
+  handleSentryGun: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
     const messages = [];
-    let statusMsg = `❄️ 【寒冷】生效：当前${freezingLayers}层“寒冷”`;
-    statusMsg += `，受到的伤害+${damageIncrease}%`;
-    if (damageIncrease >= maxIncrease) {
-      statusMsg += ``;
+    let targetUpdates = null;
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("岗哨机枪")) {
+      return null;
     }
-    messages.push(statusMsg);
-    return {
-      damageMultiplier: effectiveLayers * 0.025,
-      // 每层2.5%增伤
-      messages
-    };
-  }, "calculateColdDamage"),
-  // === 电能相关被动处理 ===
-  // 处理导体标签变化（血量低时护盾->重甲）
-  handleConductorTagChange: /* @__PURE__ */ __name(async (ctx, targetBoss, currentHP, maxHP) => {
-    const triggerThreshold = targetBoss.skills.includes("超导体") ? 0.05 : 0.1;
-    const isBelowThreshold = currentHP <= maxHP * triggerThreshold;
-    const hasShieldTag = targetBoss.tags.includes("护盾");
-    const alreadyHeavyArmor = targetBoss.tags.includes("重甲");
-    if (!targetBoss.skills.includes("超导体") && !targetBoss.skills.includes("电能导体")) return null;
-    if (isBelowThreshold && hasShieldTag && !alreadyHeavyArmor) {
-      const newTags = [
-        ...targetBoss.tags.filter((tag) => tag !== "护盾"),
-        "重甲"
-      ];
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { tags: newTags }
-      );
-      return {
-        messages: [`⚡ 【${targetBoss.skills.includes("超导体") ? "超导体" : "电能导体"}】生效：护盾崩溃，标签变更为「重甲」`]
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks < 10) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          skillStacksChanged: 1
+          // 层数+1
+        }
       };
-    }
-    return null;
-  }, "handleConductorTagChange"),
-  // 处理能量虹吸减伤（基于血量）
-  handleEnergySiphon: /* @__PURE__ */ __name((targetBoss, currentHP, maxHP) => {
-    if (!targetBoss.skills.includes("能量虹吸")) return null;
-    let reduction = 0;
-    if (currentHP >= maxHP * 0.7) {
-      reduction = 0.4;
-    } else if (currentHP >= maxHP * 0.3) {
-      reduction = 0.2;
-    }
-    if (reduction > 0) {
+      const newStacks = currentStacks + 1;
+      messages.push(`🔫 【岗哨机枪】充能：当前累计${newStacks}/10次攻击`);
       return {
-        damageMultiplier: -reduction,
-        messages: [`🔋 【能量虹吸】生效：血量${currentHP > maxHP * 0.7 ? ">70%" : ">30%"}，受到的伤害-${reduction * 100}%`]
+        messages,
+        targetUpdates,
+        otherUpdates
       };
     }
-    return null;
-  }, "handleEnergySiphon"),
-  // 处理电能冲击波（受击回复能量）
-  handleEnergyShockwave: /* @__PURE__ */ __name(async (ctx, targetBoss) => {
-    if (!targetBoss.skills.includes("电能冲击波")) return null;
-    const energyGain = 100;
-    const currentEnergy = targetBoss.energy || 0;
-    const newEnergy = Math.min(currentEnergy + energyGain, 1e3);
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { energy: newEnergy }
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -currentStacks
+        // 重置层数
+      }
+    };
+    messages.push(`🔫 【岗哨机枪】生效：累计承受10次攻击，为所有其他存活异形回复生命值`);
+    const otherSurvivingBosses = activeBosses.filter(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
     );
-    const actualGain = newEnergy - currentEnergy;
+    otherSurvivingBosses.forEach((otherBoss) => {
+      const otherName = otherBoss.name;
+      const otherMaxHP = getMaxHPByName(otherName);
+      const healAmount = Math.round(otherMaxHP * 0.1);
+      otherUpdates.push({
+        name: otherName,
+        updates: {
+          hpChange: healAmount
+          // 生命值回复
+        }
+      });
+      messages.push(`🔫 【岗哨机枪】触发：为「${otherName}」回复${healAmount}点生命值`);
+    });
     return {
-      messages: [
-        `⚡ 【电能冲击波】生效：${actualGain > 0 ? `回复${actualGain}点能量` : "能量已达上限"}`,
-        `当前能量: ${newEnergy}/${1e3}`
-      ].filter(Boolean)
+      messages,
+      targetUpdates,
+      otherUpdates
     };
-  }, "handleEnergyShockwave"),
-  // 处理能源虹吸减伤（基于能量）
-  handlePowerSiphon: /* @__PURE__ */ __name((targetBoss) => {
-    if (!targetBoss.skills.includes("能源虹吸")) return null;
-    const currentEnergy = targetBoss.energy || 0;
-    let reduction = 0;
-    if (currentEnergy >= 800) {
-      reduction = 0.5;
-    } else if (currentEnergy >= 500) {
-      reduction = 0.3;
-    }
-    if (reduction > 0) {
-      return {
-        damageMultiplier: -reduction,
-        messages: [`🔋 【能源虹吸】生效：能量${currentEnergy > 800 ? ">80%" : ">50%"}，受到的伤害-${reduction * 100}%`]
-      };
-    }
-    return null;
-  }, "handlePowerSiphon"),
-  // 处理电能立场（概率免疫伤害）
-  handleEnergyField: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName, initialDamage) {
-    if (!targetBoss.skills.includes("电能立场") || initialDamage === 0 || weaponName === "零度之下") {
+  }, "handleSentryGun"),
+  // 结构装甲处理（常规伤害降低20%；热能武器伤害降低40%）
+  handleStructuralArmor: /* @__PURE__ */ __name(function(targetBoss, weaponData) {
+    const messages = [];
+    if (!targetBoss.skills.includes("结构装甲")) {
       return null;
     }
-    const currentEnergy = targetBoss.energy || 0;
-    const currentFreezing = targetBoss.freezing || 0;
-    let immuneChance = 55 - currentFreezing * 5;
-    immuneChance = Math.max(immuneChance, 5);
-    if (currentEnergy < 300) {
+    const weaponType = weaponData.type;
+    const isHeatWeapon = weaponType === "热能武器";
+    const nerfMultiplier = isHeatWeapon ? 0.4 : 0.2;
+    messages.push(`🛡️ 【结构装甲】生效：${isHeatWeapon ? "热能武器" : "常规武器"}伤害降低${nerfMultiplier * 100}%`);
+    return {
+      nerfMultiplier,
+      messages
+    };
+  }, "handleStructuralArmor"),
+  // 吸血唾液处理（叠加「吸血」层数，每层提供5%减伤，最多20层）
+  handleVampireSaliva: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("吸血唾液")) {
       return null;
     }
-    const roll = Math.random() * 100;
-    if (roll <= immuneChance) {
-      return {
-        immune: true,
-        messages: [
-          `🛡️ 【电能立场】生效：免疫非寒冷伤害！`
-        ]
+    const currentStacks = targetBoss.skillStacks || 0;
+    const addStacks = currentStacks < 20 ? 1 : 0;
+    const addedReduction = currentStacks * 0.05;
+    let targetUpdates = null;
+    if (addStacks > 0) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          skillStacksChanged: addStacks
+          // 实际增加的层数（0或1）
+        }
       };
     }
-    return null;
-  }, "handleEnergyField"),
-  // 辅助函数：从配置中获取成员配置
-  getMemberConfig: /* @__PURE__ */ __name((name2, bossGroup) => {
-    if (bossGroup.main.name === name2) return bossGroup.main;
-    for (const minion of bossGroup.minions) {
-      if (minion.name === name2) return minion;
+    const stackMessage = currentStacks < 20 ? `当前${currentStacks}层，获得${(addedReduction * 100).toFixed(0)}%减伤，同时层数+1` : `已达到最大20层，获得${(addedReduction * 100).toFixed(0)}%减伤`;
+    messages.push(`🩸 【吸血唾液】${stackMessage}`);
+    return {
+      nerfMultiplier: addedReduction,
+      messages,
+      targetUpdates
+    };
+  }, "handleVampireSaliva"),
+  // 进食处理（吸血层数达到20层时，回复20%最大生命值）
+  handleFeeding: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("进食")) {
+      return null;
     }
-    return null;
-  }, "getMemberConfig"),
-  // 修改后的脉冲处理函数
-  handlePulse: /* @__PURE__ */ __name(async function(ctx, targetBoss, activeBosses, bossGroup, currentHP) {
-    if (!targetBoss.skills.includes("脉冲")) return null;
-    const currentEnergy = targetBoss.energy || 0;
-    const currentFreezing = targetBoss.freezing || 0;
-    const maxEnergy = 1e3;
-    if (currentEnergy < maxEnergy * 0.3) {
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks < 20) {
       return null;
     }
-    let triggerChance = 60 - currentFreezing * 5;
-    triggerChance = Math.max(triggerChance, 5);
-    const roll = Math.random() * 100;
-    if (roll <= triggerChance) {
-      const groupMembers = activeBosses.filter(
-        (b) => b.groupId === targetBoss.groupId && b.HP > 0
-        // 只包括存活的异形
-      );
-      const updates = [];
-      const healMessages = [];
-      let updatedHP = currentHP;
-      for (const member of groupMembers) {
-        const memberConfig = this.getMemberConfig(member.name, bossGroup);
-        if (!memberConfig) continue;
-        const maxHP = memberConfig.maxHP;
-        const healAmount = member.type === "主宰" ? 100 : 100;
-        const newHP = Math.min(member.HP + healAmount, maxHP);
-        const actualHeal = newHP - member.HP;
-        if (member.name === targetBoss.name) {
-          updatedHP = newHP;
-        }
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: member.name },
-            { HP: newHP }
-          )
-        );
-        if (actualHeal > 0) {
-          healMessages.push(`${member.name}+${actualHeal}HP`);
-        }
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const healAmount = Math.round(maxHP * 0.2);
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -currentStacks,
+        // 层数清零
+        hpChange: healAmount
+        // 生命值回复
       }
-      if (healMessages.length > 0) {
-        await Promise.all(updates);
-        return {
-          newHP: updatedHP,
-          // 返回当前目标的新HP值
-          messages: [
-            `❤️ 【脉冲】生效：治疗全体异形`,
-            ...healMessages
-          ]
+    };
+    messages.push(`🍽️ 【进食】生效：消耗20层吸血唾液，回复${healAmount}点生命值`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleFeeding"),
+  // 嗜血狂暴处理（生命值低于50%时，叠加吸血层数并降低20%伤害）
+  handleBloodlust: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    let nerfMultiplier = 0;
+    if (!targetBoss.skills.includes("嗜血狂暴")) {
+      return null;
+    }
+    const currentHP = targetBoss.HP;
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const currentStacks = targetBoss.skillStacks || 0;
+    const isLowHP = currentHP <= maxHP * 0.5;
+    if (isLowHP) {
+      if (currentStacks < 20) {
+        targetUpdates = {
+          name: targetBoss.name,
+          updates: {
+            skillStacksChanged: 1
+            // 层数+1
+          }
         };
       }
+      nerfMultiplier = 0.2;
+      const stackMessage = currentStacks < 20 ? `额外叠加1层吸血唾液（当前${currentStacks + 1}/20层）` : `已达到最大20层吸血唾液`;
+      messages.push(`🔥 【嗜血狂暴】生效：HP≤50%，${stackMessage}，并且获得20%额外减伤`);
+    }
+    return {
+      nerfMultiplier,
+      messages,
+      targetUpdates
+    };
+  }, "handleBloodlust"),
+  // 吐血处理（无「吸血唾液」层数时，所受伤害提升20%）
+  handleVomit: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("吐血")) {
       return null;
     }
-    return null;
-  }, "handlePulse"),
-  // 处理弧焊枪的能量消耗
-  handleArcWelderEffect: /* @__PURE__ */ __name(async (ctx, targetBoss, weaponName) => {
-    if (weaponName !== "弧焊枪") return null;
-    const currentEnergy = targetBoss.energy || 0;
+    const currentVampireStacks = targetBoss.skillStacks || 0;
+    const isTriggered = currentVampireStacks === 0;
+    const buffMultiplier = isTriggered ? 0.2 : 0;
+    if (isTriggered) {
+      messages.push(`🩸 【吐血】生效：无「吸血唾液」层数，所受伤害提升20%`);
+    }
+    return {
+      buffMultiplier,
+      messages
+    };
+  }, "handleVomit"),
+  // 超导体（状态转换：护盾→重甲）
+  handleSuperconductor: /* @__PURE__ */ __name(function(targetBoss) {
     const messages = [];
-    let arcApplied = false;
-    if (currentEnergy > 0) {
-      const energyDrain = Math.min(200, currentEnergy);
-      const newEnergy = currentEnergy - energyDrain;
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { energy: newEnergy }
-      );
-      arcApplied = true;
-      messages.push(`⚡ 【弧焊枪】武器效果：消耗目标200点能量`);
-    } else {
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("超导体")) {
       return null;
     }
-    return { messages, arcApplied };
-  }, "handleArcWelderEffect"),
-  // 在 PassiveHandler 对象中添加新的处理函数
-  handleArcRifleEffect: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName, messages) {
-    if (weaponName !== "DG-3电弧步枪") return null;
-    const currentEnergy = targetBoss.energy || 0;
-    const drainAmount = Math.min(500, currentEnergy);
-    const newEnergy = currentEnergy - drainAmount;
-    if (drainAmount <= 0) {
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const hpPercent = targetBoss.HP / maxHP;
+    const hasShieldTag = targetBoss.tags.includes("护盾") || false;
+    if (hpPercent > 0.1 || !hasShieldTag) {
       return null;
     }
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { energy: newEnergy }
-    );
-    targetBoss.energy = newEnergy;
-    messages.push(`⚡ 【DG-3电弧步枪】武器效果：消耗目标${drainAmount}点能量`);
-    return { drainAmount };
-  }, "handleArcRifleEffect"),
-  // 庞兽狂暴处理（血量低于50%时减伤）
-  handleGiantRage: /* @__PURE__ */ __name(function(targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("庞兽狂暴")) return null;
-    if (currentHP / maxHP < 0.5) {
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        tagsRemoved: ["护盾"],
+        // 移除护盾标签
+        tagsAdded: ["重甲"]
+        // 添加重甲标签
+      }
+    };
+    messages.push(`🛡️ 【超导体】生效：生命值≤10%，「护盾」标签转换为「重甲」标签`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleSuperconductor"),
+  // 能量虹吸（生命值相关减伤）
+  handleEnergySiphon: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("能量虹吸")) return null;
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const hpPercent = targetBoss.HP / maxHP;
+    let nerfMultiplier = 0;
+    if (hpPercent >= 0.7) {
+      nerfMultiplier = 0.4;
+      messages.push(`⚡ 【能量虹吸】生效：生命值≥70%，所受伤害降低40%`);
+    } else if (hpPercent >= 0.3) {
+      nerfMultiplier = 0.2;
+      messages.push(`⚡ 【能量虹吸】生效：生命值≥30%，所受伤害降低20%`);
+    }
+    return { nerfMultiplier, messages };
+  }, "handleEnergySiphon"),
+  // 能源虹吸（能量值相关减伤）
+  handleEnergyAbsorption: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("能源虹吸")) return null;
+    const currentEnergy = targetBoss.energy;
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const energyPercent = currentEnergy / maxEnergy;
+    let nerfMultiplier = 0;
+    if (energyPercent >= 0.8) {
+      nerfMultiplier = 0.5;
+      messages.push(`⚡ 【能源虹吸】生效：能量≥80%，所受伤害降低50%`);
+    } else if (energyPercent >= 0.5) {
+      nerfMultiplier = 0.3;
+      messages.push(`⚡ 【能源虹吸】生效：能量≥50%，所受伤害降低30%`);
+    }
+    return { nerfMultiplier, messages };
+  }, "handleEnergyAbsorption"),
+  // 电能立场（能量相关免疫）
+  handleElectricField: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let isImmune = false;
+    if (!targetBoss.skills.includes("电能立场")) return null;
+    const currentEnergy = targetBoss.energy;
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const energyPercent = currentEnergy / maxEnergy;
+    if (energyPercent < 0.3) {
+      return null;
+    }
+    const coldLayers = targetBoss.coldLayers || 0;
+    const baseChance = 0.55;
+    const coldPenalty = coldLayers * 0.05;
+    const immuneChance = Math.max(baseChance - coldPenalty, 0.05);
+    isImmune = Math.random() < immuneChance;
+    const chancePercent = Math.round(immuneChance * 100);
+    messages.push(`⚡ 【电能立场】生效：能量≥30%，免疫概率${chancePercent}%` + (isImmune ? " → 免疫成功" : " → 未免疫"));
+    return { isImmune, messages };
+  }, "handleElectricField"),
+  // 电能冲击波（能量回复）
+  handleElectricShockwave: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("电能冲击波")) {
+      return null;
+    }
+    const currentEnergy = targetBoss.energy || 0;
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const maxHealAmount = 100;
+    const actualHealAmount = Math.min(maxHealAmount, maxEnergy - currentEnergy);
+    if (actualHealAmount <= 0) {
+      messages.push(`⚡ 【电能冲击波】生效：能量已达上限`);
       return {
-        damageMultiplier: -0.5,
-        messages: [`🐗 【庞兽狂暴】生效：进入狂暴状态，受到的伤害-50%`]
+        messages,
+        targetUpdates: null
       };
     }
-    return null;
-  }, "handleGiantRage"),
-  // 修改后的灼烧粘液处理
-  handleBileStacking: /* @__PURE__ */ __name(async function(ctx, targetBoss, skipStack) {
-    if (!targetBoss.skills.includes("灼烧粘液") || skipStack) return null;
-    const currentStacks = targetBoss.Skillcountpoints || 0;
-    const newStacks = Math.min(currentStacks + 1, 20);
-    let messages = [`💧 【灼烧粘液】生效：获得1层"胆汁"(当前${newStacks}层)`];
-    if (currentStacks < 10 && newStacks >= 10) {
-      if (targetBoss.skills.includes("腐蚀胆汁")) {
-        messages.push(`🟢 胆汁达到10层，下次攻击将触发【腐蚀胆汁】`);
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        energyChange: maxHealAmount
+        // 回复量
+      }
+    };
+    messages.push(`⚡ 【电能冲击波】生效：回复${maxHealAmount}点能量`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleElectricShockwave"),
+  // 脉冲（生命回复）
+  handlePulse: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("脉冲")) {
+      return null;
+    }
+    const currentEnergy = targetBoss.energy || 0;
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const energyPercent = maxEnergy > 0 ? currentEnergy / maxEnergy : 0;
+    if (energyPercent < 0.3) {
+      return null;
+    }
+    const coldLayers = targetBoss.coldLayers || 0;
+    const baseChance = 0.6;
+    const coldPenalty = coldLayers * 0.05;
+    const triggerChance = Math.max(baseChance - coldPenalty, 0.1);
+    if (Math.random() >= triggerChance) {
+      return null;
+    }
+    const survivors = activeBosses.filter((b) => b.isActive);
+    survivors.forEach((survivor) => {
+      const healAmount = 100;
+      if (healAmount > 0) {
+        otherUpdates.push({
+          name: survivor.name,
+          updates: { hpChange: healAmount }
+        });
+        messages.push(`⚡ 【脉冲】生效：为「${survivor.name}」回复${healAmount}点生命值`);
       }
+    });
+    return {
+      messages,
+      otherUpdates
+    };
+  }, "handlePulse"),
+  // 能量黑洞（固定减伤）
+  handleEnergyBlackhole: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("能量黑洞")) return null;
+    messages.push(`⚡ 【能量黑洞】生效：存在「能量黑洞」时，所受伤害降低20%`);
+    return { nerfMultiplier: 0.2, messages };
+  }, "handleEnergyBlackhole"),
+  // 火焰异形（免疫伤害并回复生命值）
+  handleFlameAlien: /* @__PURE__ */ __name(function(targetBoss, weaponName, damage) {
+    const messages = [];
+    let isImmune = false;
+    if (!targetBoss.skills.includes("火焰异形")) {
+      return null;
+    }
+    const isFireDamage = weaponName === "焚烧枪";
+    if (!isFireDamage) {
+      return null;
     }
-    if (currentStacks < 20 && newStacks >= 20) {
-      if (targetBoss.skills.includes("火焰吐息")) {
-        messages.push(`🐲 胆汁达到20层，下次攻击将触发【火焰吐息】`);
+    isImmune = true;
+    const healAmount = damage;
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        hpChange: healAmount
+        // 生命值变化量
       }
+    };
+    messages.push(`🔥 【火焰异形】生效：「${targetBoss.boss}」免疫火焰伤害`);
+    messages.push(`🔥 恢复${healAmount}点生命值`);
+    return {
+      isImmune,
+      messages,
+      targetUpdates
+    };
+  }, "handleFlameAlien"),
+  // 庞兽狂暴 - 低生命时减伤
+  handleColossalRampage: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("庞兽狂暴")) {
+      return null;
     }
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: newStacks }
-    );
-    return { messages };
-  }, "handleBileStacking"),
-  // 修改后的太阳耀斑处理（每次受击检测）
-  handleSolarFlare: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName) {
-    if (!targetBoss.skills.includes("太阳耀斑") || targetBoss.type !== "主宰") {
-      return { immune: false, messages: [] };
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const hpPercent = targetBoss.HP / maxHP;
+    let nerfMultiplier = 0;
+    if (hpPercent < 0.5) {
+      nerfMultiplier = 0.5;
+      messages.push(`💥 【庞兽狂暴】生效：生命值低于50%，狂暴状态下所受伤害降低50%`);
     }
+    return { nerfMultiplier, messages };
+  }, "handleColossalRampage"),
+  handleBurningSlime: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
     const messages = [];
-    let immune = false;
-    const minions = await ctx.database.get("ggcevo_boss", {
-      groupId: targetBoss.groupId,
-      type: "子代",
-      isActive: true
-    });
-    const aliveMinions = minions.filter((m) => m.HP > 0);
-    if (aliveMinions.length === 0) {
-      const updates = [];
-      if (targetBoss.tags.includes("惧寒")) {
-        const newTags = targetBoss.tags.filter((tag) => tag !== "惧寒");
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: targetBoss.name },
-            { tags: newTags }
-          )
-        );
-        targetBoss.tags = newTags;
-        messages.push(`☀️ 【太阳耀斑】生效：移除"惧寒"标签`);
-      }
-      if (targetBoss.skills.includes("孤立无援")) {
-        const newSkills = targetBoss.skills.filter((skill) => skill !== "孤立无援");
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: targetBoss.name },
-            { skills: newSkills }
-          )
-        );
-        targetBoss.skills = newSkills;
-        messages.push(`☀️ 【太阳耀斑】生效：移除"孤立无援"技能`);
+    let targetUpdates = null;
+    let isHighStackHeal = false;
+    if (!targetBoss.skills.includes("灼烧粘液")) {
+      return null;
+    }
+    const currentStacks = targetBoss.skillStacks || 0;
+    const maxStacks = 20;
+    const isFireDamage = weaponName === "焚烧枪";
+    const updates = {};
+    if (!isFireDamage && currentStacks < maxStacks) {
+      updates.skillStacksChanged = 1;
+      const newStacks = currentStacks + 1;
+      messages.push(`🔥 【灼烧粘液】叠加：当前层数${newStacks}/${maxStacks}`);
+    }
+    if (isFireDamage && currentStacks > 0) {
+      const healAmount = currentStacks * 10;
+      updates.hpChange = healAmount;
+      updates.skillStacksChanged = -currentStacks;
+      if (currentStacks >= 10) {
+        isHighStackHeal = true;
+        messages.push(`🔥 【灼烧粘液】强力回复：消耗${currentStacks}层（≥10），回复${healAmount}点生命值！`);
+      } else {
+        messages.push(`🔥 【灼烧粘液】生效：消耗${currentStacks}层，回复${healAmount}点生命值`);
       }
-      await Promise.all(updates);
     }
-    if (!targetBoss.tags.includes("惧寒") && weaponName === "零度之下") {
-      immune = true;
-      messages.push(`☀️ 【太阳耀斑】生效：免疫寒冷伤害`);
+    if (Object.keys(updates).length > 0) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates
+      };
     }
-    return { immune, messages };
-  }, "handleSolarFlare"),
-  // 辅助函数：从配置中获取成员的最大生命值
-  getMemberMaxHP: /* @__PURE__ */ __name(function(name2, bossGroup) {
-    if (bossGroup.main.name === name2) return bossGroup.main.maxHP;
-    for (const minion of bossGroup.minions) {
-      if (minion.name === name2) return minion.maxHP;
+    return {
+      messages,
+      targetUpdates,
+      isHighStackHeal
+      // 新增的标记字段
+    };
+  }, "handleBurningSlime"),
+  // 腐蚀胆汁 - 群体回复机制
+  handleCorrosiveBile: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    let targetUpdates = null;
+    const requiredStacks = 10;
+    if (!targetBoss.skills.includes("腐蚀胆汁")) {
+      return null;
     }
-    return null;
-  }, "getMemberMaxHP"),
-  // 修改后的腐蚀胆汁处理函数
-  handleCorrosiveBile: /* @__PURE__ */ __name(async function(ctx, targetBoss, bossGroup, currentHP) {
-    if (!targetBoss.skills.includes("腐蚀胆汁")) return null;
-    const bileStacks = targetBoss.Skillcountpoints || 0;
-    if (bileStacks < 10) return null;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: 0 }
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks < requiredStacks) {
+      return null;
+    }
+    const otherSurvivingBosses = activeBosses.filter(
+      (boss) => boss.isActive
     );
-    const messages = [
-      `🟢 【腐蚀胆汁】生效：消耗10层"胆汁"，治疗所有存活异形`
-    ];
-    const updates = [];
-    let updatedHP = currentHP;
-    const groupMembers = await ctx.database.get("ggcevo_boss", {
-      groupId: targetBoss.groupId,
-      isActive: true,
-      HP: { $gt: 0 }
-    });
-    for (const member of groupMembers) {
-      const maxHP = this.getMemberMaxHP(member.name, bossGroup);
-      if (!maxHP) continue;
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -currentStacks
+        // 重置层数为0
+      }
+    };
+    messages.push(`🧪 【腐蚀胆汁】触发：灼烧粘液达到${currentStacks}层，为所有存活异形回复生命值`);
+    otherSurvivingBosses.forEach((otherBoss) => {
+      const otherName = otherBoss.name;
       const healAmount = 1e3;
-      const newHP = Math.min(member.HP + healAmount, maxHP);
-      const actualHeal = newHP - member.HP;
-      if (member.name === targetBoss.name) {
-        updatedHP = newHP;
-      }
-      updates.push(
-        ctx.database.set(
-          "ggcevo_boss",
-          { name: member.name },
-          { HP: newHP }
-        )
-      );
-      messages.push(`${member.name} 回复${actualHeal}点生命值`);
-    }
-    await Promise.all(updates);
-    return { messages, currentHP: updatedHP };
+      if (healAmount > 0) {
+        otherUpdates.push({
+          name: otherName,
+          updates: { hpChange: healAmount }
+        });
+        messages.push(`🧪 【腐蚀胆汁】生效：为「${otherName}」回复${healAmount}点生命值`);
+      }
+    });
+    return {
+      messages,
+      targetUpdates,
+      otherUpdates
+    };
   }, "handleCorrosiveBile"),
-  // 修改后的火焰吐息处理函数
-  handleFireBreath: /* @__PURE__ */ __name(async function(ctx, targetBoss, bossGroup, currentHP) {
-    if (!targetBoss.skills.includes("火焰吐息")) return null;
-    const bileStacks = targetBoss.Skillcountpoints || 0;
-    if (bileStacks < 20) return null;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: 0 }
+  // 火焰吐息 - 高级群体回复机制
+  handleFlameBreath: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    let targetUpdates = null;
+    const requiredStacks = 20;
+    if (!targetBoss.skills.includes("火焰吐息")) {
+      return null;
+    }
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks < requiredStacks) {
+      return null;
+    }
+    const otherSurvivingBosses = activeBosses.filter(
+      (boss) => boss.isActive
     );
-    const messages = [
-      `🐲 【火焰吐息】生效：消耗20层"胆汁"，治疗所有存活异形50%的最大生命值`
-    ];
-    const updates = [];
-    let updatedHP = currentHP;
-    const groupMembers = await ctx.database.get("ggcevo_boss", {
-      groupId: targetBoss.groupId,
-      isActive: true,
-      HP: { $gt: 0 }
-    });
-    for (const member of groupMembers) {
-      const maxHP = this.getMemberMaxHP(member.name, bossGroup);
-      if (!maxHP) continue;
-      const healAmount = Math.floor(maxHP * 0.5);
-      const newHP = Math.min(member.HP + healAmount, maxHP);
-      const actualHeal = newHP - member.HP;
-      if (member.name === targetBoss.name) {
-        updatedHP = newHP;
-      }
-      updates.push(
-        ctx.database.set(
-          "ggcevo_boss",
-          { name: member.name },
-          { HP: newHP }
-        )
-      );
-      messages.push(`${member.name} 回复${actualHeal}点生命值`);
-    }
-    await Promise.all(updates);
-    return { messages, currentHP: updatedHP };
-  }, "handleFireBreath"),
-  // 修改后的火焰异形处理
-  handleFireEvolution: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName, initialDamage, bossGroup) {
-    if (targetBoss.skills.includes("火焰异形") && weaponName === "焚烧枪") {
-      const maxHP = this.getMemberMaxHP(targetBoss.name, bossGroup);
-      if (!maxHP) return null;
-      const healAmount = Math.min(initialDamage, maxHP - targetBoss.HP);
-      let updatedHP = Math.min(targetBoss.HP + healAmount, maxHP);
-      const messages = [
-        `🔥 【火焰异形】生效：免疫火焰伤害`,
-        healAmount > 0 ? `${targetBoss.name}回复${healAmount}点生命值` : ""
-      ].filter(Boolean);
-      const bileResult = await this.handleBileIgnition(ctx, targetBoss, bossGroup, updatedHP);
-      if (bileResult) {
-        updatedHP = bileResult.newHP;
-        messages.push(...bileResult.messages);
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: -currentStacks
+        // 重置层数为0
       }
-      return {
-        updatedHP,
-        initialDamage: 0,
-        // 免疫伤害
-        messages,
-        bileStacks: bileResult?.bileStacks || 0
-      };
+    };
+    messages.push(`🔥 【火焰吐息】触发：灼烧粘液达到${currentStacks}层，为所有存活异形回复20%最大生命值`);
+    otherSurvivingBosses.forEach((otherBoss) => {
+      const otherName = otherBoss.name;
+      const maxHP = getMaxHPByName(otherName);
+      const healAmount = Math.round(maxHP * 0.2);
+      if (healAmount > 0) {
+        otherUpdates.push({
+          name: otherName,
+          updates: { hpChange: healAmount }
+        });
+        messages.push(`🔥 【火焰吐息】生效：为「${otherName}」回复${healAmount}点生命值`);
+      }
+    });
+    return {
+      messages,
+      targetUpdates,
+      otherUpdates
+    };
+  }, "handleFlameBreath"),
+  // 太阳耀斑 - 移除状态并获得免疫
+  handleSolarFlare: /* @__PURE__ */ __name(function(targetBoss, weaponName, damage, activeBosses) {
+    const messages = [];
+    let isImmune = false;
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("太阳耀斑")) {
+      return null;
     }
-    return null;
-  }, "handleFireEvolution"),
-  // 修改后的灼烧粘液引爆
-  handleBileIgnition: /* @__PURE__ */ __name(async function(ctx, targetBoss, bossGroup, updatedHP) {
-    if (!targetBoss.skills.includes("灼烧粘液")) return null;
-    const bileStacks = targetBoss.Skillcountpoints || 0;
-    if (bileStacks < 1) return null;
-    const maxHP = this.getMemberMaxHP(targetBoss.name, bossGroup);
-    if (!maxHP) return null;
-    const healAmount = bileStacks * 10;
-    const newHP = Math.min(updatedHP + healAmount, maxHP);
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: 0, HP: newHP }
+    const hasLivingOffspring = activeBosses.some(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
     );
+    const hasFearColdTag = targetBoss.tags.includes("惧寒") || false;
+    if (hasLivingOffspring || !hasFearColdTag) {
+      return null;
+    }
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        tagsRemoved: ["惧寒"]
+      }
+    };
+    messages.push(`☀️ 【太阳耀斑】生效：无存活子代，移除「惧寒」状态`);
+    const isColdWeapon = weaponName === "零度之下";
+    if (isColdWeapon) {
+      isImmune = true;
+      messages.push(`☀️ 【太阳耀斑】触发：免疫寒冷伤害`);
+    }
     return {
-      messages: [
-        `💥 【灼烧粘液】引爆：消耗${bileStacks}层"胆汁"，${targetBoss.name}回复${healAmount}点生命值`
-      ],
-      newHP,
-      bileStacks
+      isImmune,
+      messages,
+      targetUpdates
     };
-  }, "handleBileIgnition"),
-  // 燃烧潜地处理函数
-  handleBurningBurrow: /* @__PURE__ */ __name(async function(ctx, targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("燃烧潜地") || currentHP <= 0 || // 确保血量大于0
-    currentHP / maxHP > 0.1) {
+  }, "handleSolarFlare"),
+  // 燃烧潜地 - 低生命回复
+  handleBurningBurrow: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("燃烧潜地")) {
       return null;
     }
-    const healAmount = Math.floor(maxHP * 0.5);
-    const updatedHP = Math.min(currentHP + healAmount, maxHP);
-    return {
-      updatedHP,
-      messages: [`🔥 【燃烧潜地】生效：回复50%最大生命值(+${healAmount}HP)`],
-      skillUpdates: [{
-        name: targetBoss.name,
-        remove: ["燃烧潜地"]
-      }]
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    const hpPercent = currentHP / maxHP;
+    if (hpPercent >= 0.1) {
+      return null;
+    }
+    const healAmount = Math.round(maxHP * 0.5);
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillsRemoved: ["燃烧潜地"],
+        // 移除技能
+        hpChange: healAmount
+        // 回复生命值
+      }
     };
-  }, "handleBurningBurrow"),
-  // 修改后的炼狱爆弹处理函数（不再使用 async/await）
-  handleHellfireBomb: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
-    if (!targetBoss.skills.includes("炼狱爆弹")) return null;
-    const bileStacks = targetBoss.Skillcountpoints || 0;
-    if (bileStacks < 1) return null;
-    const hasLivingMinions = activeBosses.some(
-      (boss) => boss.groupId === targetBoss.groupId && boss.type === "子代" && boss.HP > 0
-    );
-    const baseReductionPerStack = 0.05;
-    const bonusReductionPerStack = hasLivingMinions ? 0.05 : 0;
-    const totalReductionPerStack = baseReductionPerStack + bonusReductionPerStack;
-    const reduction = bileStacks * totalReductionPerStack;
-    const messageParts = [
-      `💣 【炼狱爆弹】生效：当前${bileStacks}层胆汁，受到的伤害-${(reduction * 100).toFixed(0)}%`
-    ];
+    messages.push(`🔥 【燃烧潜地】生效：生命值低于10%，立即回复${healAmount}点生命值（效果移除）`);
     return {
-      damageMultiplier: -reduction,
-      messages: messageParts
+      messages,
+      targetUpdates
     };
-  }, "handleHellfireBomb"),
-  // 猎手异形处理（Hunter Alien）
-  handleHunterAlien: /* @__PURE__ */ __name(async function(targetBoss, weaponName, activeBosses) {
-    if (!targetBoss.skills.includes("猎手异形")) return null;
-    if (weaponName === "焚烧枪" || weaponName === "零度之下") {
-      return {
-        immune: true,
-        messages: [`🛡️ 【猎手异形】生效：免疫${weaponName === "焚烧枪" ? "火焰" : "寒冷"}伤害`]
-      };
+  }, "handleBurningBurrow"),
+  // 炼狱爆弹 - 基于层数和子代的减伤
+  handleInfernalBomb: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    if (!targetBoss.skills.includes("炼狱爆弹")) {
+      return null;
     }
-    const otherAlive = activeBosses.some(
-      (boss) => boss.groupId === targetBoss.groupId && boss.name !== targetBoss.name && boss.HP > 0
+    const currentStacks = targetBoss.skillStacks || 0;
+    const hasLivingOffspring = activeBosses.some(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
     );
-    const multiplier = otherAlive ? -0.2 : 0.2;
+    let baseReduction = currentStacks * 0.05;
+    let extraReduction = 0;
+    if (hasLivingOffspring) {
+      extraReduction = currentStacks * 0.05;
+    }
+    nerfMultiplier = baseReduction + extraReduction;
+    if (nerfMultiplier > 0) {
+      const reductionPercent = Math.round(nerfMultiplier * 100);
+      const offspringMsg = hasLivingOffspring ? "（存在子代，额外加成）" : "";
+      messages.push(`💣 【炼狱爆弹】生效：灼烧粘液${currentStacks}层，获得${reductionPercent}%减伤${offspringMsg}`);
+    }
+    return { nerfMultiplier, messages };
+  }, "handleInfernalBomb"),
+  // 猎手异形处理（条件增减伤 + 火焰/寒冷免疫）
+  handleHunterAlien: /* @__PURE__ */ __name(function(targetBoss, activeBosses, weaponName) {
+    const messages = [];
+    let buffMultiplier = 0;
+    let nerfMultiplier = 0;
+    let isImmune = false;
+    if (!targetBoss.skills.includes("猎手异形")) {
+      return null;
+    }
+    const isFireDamage = weaponName === "焚烧枪";
+    const isColdDamage = weaponName === "零度之下";
+    if (isFireDamage || isColdDamage) {
+      isImmune = true;
+      messages.push(`🦖 【猎手异形】生效：免疫${isFireDamage ? "火焰" : "寒冷"}伤害`);
+    }
+    const otherLivingAliens = activeBosses.filter(
+      (boss) => boss.name !== targetBoss.name && boss.isActive
+    ).length;
+    if (otherLivingAliens > 0) {
+      nerfMultiplier = 0.2;
+      messages.push(`🦖 【猎手异形】生效：存在其他存活异形，所受伤害降低20%`);
+    } else {
+      buffMultiplier = 0.2;
+      messages.push(`🦖 【猎手异形】生效：无其他存活异形，所受伤害提升20%`);
+    }
     return {
-      damageMultiplier: multiplier,
-      messages: [
-        `🕵️ 【猎手异形】生效：${otherAlive ? "有其他存活异形，受到的伤害-20%" : "无其他存活异形，受到的伤害+20%"}`
-      ]
+      buffMultiplier,
+      nerfMultiplier,
+      isImmune,
+      messages
     };
   }, "handleHunterAlien"),
-  // 狂暴处理（Rage）
-  handleRage: /* @__PURE__ */ __name(function(targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("狂暴")) return null;
-    if (currentHP / maxHP < 0.5) {
-      return {
-        damageMultiplier: -0.5,
-        messages: [`🔥 【狂暴】生效：血量低于50%，受到的伤害-50%`]
-      };
+  // 狂暴处理（低生命减伤）
+  handleRampage: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    if (!targetBoss.skills.includes("狂暴")) {
+      return null;
     }
-    return null;
-  }, "handleRage"),
-  // 伪装处理（Disguise）
-  handleDisguise: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName, initialDamage) {
-    if (!targetBoss.skills.includes("伪装")) return null;
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const currentHP = targetBoss.HP;
+    if (currentHP < maxHP * 0.5) {
+      nerfMultiplier = 0.5;
+      messages.push(`💥 【狂暴】生效：生命值低于50%，进入狂暴状态，所受伤害降低50%`);
+    }
+    return { nerfMultiplier, messages };
+  }, "handleRampage"),
+  // 伪装处理（记录武器并触发减伤）
+  handleDisguise: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
     const messages = [];
-    let damageMultiplier = 0;
-    let recordWeapon = initialDamage > 0;
-    if (targetBoss.lastWeaponName === weaponName) {
-      damageMultiplier = -0.8;
-      messages.push(`🎭 【伪装】生效：已适应武器【${weaponName}】，本次受到的伤害-80%`);
+    let nerfMultiplier = 0;
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("伪装")) {
+      return null;
     }
-    if (recordWeapon) {
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { lastWeaponName: weaponName }
-      );
-      messages.push(`🎭 【伪装】生效：记录新武器【${weaponName}】`);
+    const lastWeapon = targetBoss.lastWeaponName || null;
+    if (lastWeapon && lastWeapon === weaponName) {
+      nerfMultiplier = 0.8;
+      messages.push(`🎭 【伪装】生效：已适应武器「${weaponName}」，本次伤害降低80%`);
+    } else {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          lastWeaponName: weaponName
+          // 记录当前武器
+        }
+      };
+      messages.push(`🎭 【伪装】生效：记录新武器「${weaponName}」，下次同武器攻击伤害降低80%`);
     }
     return {
-      damageMultiplier,
-      messages
+      nerfMultiplier,
+      messages,
+      targetUpdates
     };
   }, "handleDisguise"),
-  // 致命一击处理（Critical Hit）
-  handleCriticalHit: /* @__PURE__ */ __name(function(targetBoss, initialDamage) {
-    if (!targetBoss.skills.includes("致命一击") || initialDamage === 0) return null;
-    if (Math.random() * 100 < 5) {
-      return {
-        immune: true,
-        messages: ["💥 【致命一击】生效：免疫本次伤害"]
-      };
+  // 致命一击处理（概率免疫伤害）
+  handleDeadlyHit: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let isImmune = false;
+    if (!targetBoss.skills.includes("致命一击")) {
+      return null;
     }
-    return null;
-  }, "handleCriticalHit"),
-  // 破甲模块效果处理
-  handleCorrosionModule: /* @__PURE__ */ __name((installedMods) => {
-    if (!installedMods) return 0;
-    return installedMods.includes("破甲模块") ? 0.2 : 0;
-  }, "handleCorrosionModule"),
-  // 粒子相位枪效果处理
-  handleParticlePhaseEffect: /* @__PURE__ */ __name((targetBoss, weaponName) => {
-    if (!targetBoss || weaponName !== "粒子相位枪") return 0;
-    return targetBoss.tags.includes("护盾") ? 0.5 : 0;
-  }, "handleParticlePhaseEffect"),
-  // 修改后的无视减伤处理函数
-  handleIgnoreReductionEffects: /* @__PURE__ */ __name(async (ctx, handle, weaponName, targetBoss, nerfMultiplier) => {
-    if (nerfMultiplier >= 0) return null;
-    const ignoreEffects = [];
-    let messages = [];
-    if (weaponName === "光剑") {
-      ignoreEffects.push(1);
-      messages.push(`⚔️ 【光剑】武器效果：无视目标100%减伤效果`);
-    } else if (weaponName === "M4AE脉冲步枪") {
-      ignoreEffects.push(0.8);
-      messages.push(`🔫 【M4AE脉冲步枪】武器效果：无视目标80%减伤效果`);
-    }
-    if (weaponName !== "光剑" && weaponName !== "M4AE脉冲步枪") {
-      const particleEffect = PassiveHandler.handleParticlePhaseEffect(targetBoss, weaponName);
-      if (particleEffect > 0) {
-        ignoreEffects.push(particleEffect);
-        messages.push(`⚡ 【粒子相位枪】武器效果：无视护盾目标${particleEffect * 100}%减伤效果`);
-      }
-      const weaponConfigData = weaponConfig[weaponName];
-      if (weaponConfigData) {
-        const [equippedWeapon] = await ctx.database.get("ggcevo_equipment", {
-          weaponId: weaponConfigData.id,
-          handle,
-          equipped: true
-        });
-        if (equippedWeapon?.installedMods?.includes("破甲模块")) {
-          const corrosionEffect = 0.2;
-          ignoreEffects.push(corrosionEffect);
-          messages.push(`⚡ 【破甲模块】生效：无视目标${corrosionEffect * 100}%减伤效果`);
-        }
-      }
+    if (Math.random() < 0.05) {
+      isImmune = true;
+      messages.push(`💀 【致命一击】生效：5%概率免疫本次伤害`);
     }
-    try {
-      const [careerData] = await ctx.database.get("ggcevo_careers", { handle });
-      if (careerData?.group === "辛迪加海盗") {
-        const [radarMask] = await ctx.database.get("ggcevo_warehouse", {
-          handle,
-          itemId: 6
-          // 雷达面罩ID
+    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 }
         });
-        if (radarMask && radarMask.quantity > 0) {
-          const radarEffect = 0.1;
-          ignoreEffects.push(radarEffect);
-          messages.push(`🛰️ 【雷达面罩】生效：无视目标${radarEffect * 100}%减伤效果`);
-        }
-        if (careerData?.career === "猩红杀手" && weaponName === "侦察步枪") {
-          const scarletEffect = 0.2;
-          ignoreEffects.push(scarletEffect);
-          messages.push(`🎯 【猩红杀手】职业效果：无视目标${scarletEffect * 100}%减伤效果`);
-        }
       }
-    } catch (error) {
-      console.error("出错:", error);
+      messages.push(`🌬️ 【星界之风】为「${bossName}」回复${baseHealAmount}点生命值`);
+    });
+    if (doubleChance) {
+      messages.unshift(`🌬️ 【星界之风】生效：心灵狂热状态（触发概率10%）为所有存活异形回复生命值`);
+    } else {
+      messages.unshift(`🌬️ 【星界之风】生效：5%概率触发，为所有存活异形回复生命值`);
     }
-    if (ignoreEffects.length === 0) {
+    return {
+      messages,
+      otherUpdates
+    };
+  }, "handleAstralWind"),
+  /** 心灵狂热处理（低生命减伤和概率强化）- 修正版 */
+  handleMindFrenzy: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    let doubleAstralWind = false;
+    if (!targetBoss.skills.includes("心灵狂热")) {
       return null;
     }
-    const totalIgnoreRate = Math.min(1, ignoreEffects.reduce((sum, rate) => sum + rate, 0));
+    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, activeBosses, damage) {
+    const messages = [];
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("宇宙能量")) {
+      return null;
+    }
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const currentEnergy = targetBoss.energy || 0;
+    const energyToAdd = damage;
+    const updates = {};
+    if (currentEnergy + energyToAdd <= maxEnergy) {
+      updates.energyChange = energyToAdd;
+      messages.push(`🌌 【宇宙能量】生效：吸收伤害值，获得${energyToAdd}点能量`);
+    } else {
+      const energyGained = maxEnergy - currentEnergy;
+      updates.energyChange = energyGained;
+      const overflowHeal = currentEnergy + energyToAdd - maxEnergy;
+      updates.hpChange = overflowHeal;
+      messages.push(`🌌 【宇宙能量】生效：获得${energyGained}点能量，${overflowHeal}点溢出伤害转为生命回复`);
+    }
+    targetUpdates = {
+      name: targetBoss.name,
+      updates
+    };
     return {
-      ignoreRate: totalIgnoreRate,
-      messages
+      messages,
+      targetUpdates
     };
-  }, "handleIgnoreReductionEffects"),
-  // 在PassiveHandler对象中添加处理脉冲扰乱枪效果的方法
-  handlePulseDisruptor: /* @__PURE__ */ __name(async function(ctx, targetBoss, weaponName) {
-    if (weaponName !== "脉冲扰乱枪") {
+  }, "handleCosmicEnergy"),
+  /** 复苏处理（免疫死亡并回复） */
+  handleRevival: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    if (!targetBoss.skills.includes("复苏")) {
       return null;
     }
-    const currentSkillCount = targetBoss.Skillcountpoints || 0;
-    let pulseApplied = false;
-    if (currentSkillCount <= 0) {
+    if (targetBoss.HP !== 0) {
       return null;
     }
-    const newCount = Math.max(0, currentSkillCount - 2);
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: newCount }
-    );
-    pulseApplied = true;
+    const maxHP = getMaxHPByName(targetBoss.name);
+    const maxEnergy = getMaxEnergyByName(targetBoss.name);
+    const healAmount = Math.round(maxHP * 0.5);
+    const energyGain = maxEnergy;
+    const targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        hpChange: healAmount,
+        // 回复50%最大生命值
+        energyChange: energyGain,
+        // 回复100%能量
+        skillsRemoved: ["复苏"],
+        // 移除复苏技能
+        skillsAdded: ["灵能构造炉"]
+        // 添加新技能
+      }
+    };
+    messages.push(`🔥 【复苏】生效：免疫致命伤害`);
+    messages.push(`🔥 回复${healAmount}点生命值和${energyGain}点能量`);
+    messages.push(`🔥 获得【灵能构造炉】技能，复苏效果移除`);
     return {
-      messages: [
-        `⚡ 【脉冲扰乱枪】武器效果：使${targetBoss.name}的技能层数减少2层`
-      ],
-      pulseApplied
+      messages,
+      targetUpdates
     };
-  }, "handlePulseDisruptor"),
-  // === 星界之风 ===
-  handleStellarWind: /* @__PURE__ */ __name(async (ctx, targetBoss, initialDamage, currentHP, maxHP, activeBosses, bossGroup) => {
-    if (!targetBoss.skills.includes("星界之风") || initialDamage === 0) return null;
-    let baseChance = 5;
-    const hasPsychicFrenzy = targetBoss.skills.includes("心灵狂热");
-    const isInFrenzy = targetBoss.HP / maxHP < 0.5;
-    if (hasPsychicFrenzy && isInFrenzy) {
-      baseChance *= 2;
-    }
-    let lightbladeStacks = 0;
-    if (targetBoss.skills.includes("闪电冲锋")) {
-      lightbladeStacks = targetBoss?.Skillcountpoints || 0;
-    }
-    const triggerChance = baseChance + lightbladeStacks;
-    if (Math.random() * 100 < triggerChance) {
-      const groupMembers = activeBosses.filter(
-        (b) => b.groupId === targetBoss.groupId && b.HP > 0
-      );
-      const updates = [];
-      const messages = [`🌠 【星界之风】生效：治疗所有存活异形`];
-      let updatedHP = currentHP;
-      for (const member of groupMembers) {
-        const memberConfig = PassiveHandler.getMemberConfig(member.name, bossGroup);
-        if (!memberConfig) continue;
-        const maxMemberHP = memberConfig.maxHP;
-        const healAmount = 200;
-        const actualHeal = Math.min(healAmount, maxMemberHP - member.HP);
-        if (actualHeal <= 0) continue;
-        const newHP = member.HP + actualHeal;
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: member.name },
-            { HP: newHP }
-          )
-        );
-        messages.push(`${member.name} +${actualHeal}HP`);
-        if (member.name === targetBoss.name) {
-          updatedHP = newHP;
-        }
-      }
-      if (updates.length === 0) {
-        return null;
-      }
-      await Promise.all(updates);
-      return { messages, updatedHP };
+  }, "handleRevival"),
+  /** 光影之刃处理（层数叠加） */
+  handleBladeOfLight: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    const maxStacks = 50;
+    if (!targetBoss.skills.includes("光影之刃")) {
+      return null;
     }
-    return null;
-  }, "handleStellarWind"),
-  // === 心灵狂热 ===
-  handlePsychicFrenzy: /* @__PURE__ */ __name(function(targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("心灵狂热")) return null;
-    if (currentHP / maxHP < 0.5) {
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks >= maxStacks) {
+      messages.push(`✨ 【光影之刃】已达到最大层数(${maxStacks})`);
       return {
-        damageMultiplier: -0.2,
-        // 受到的伤害-20%
-        messages: [
-          `🌀 【心灵狂热】生效：进入心灵狂热状态，受到的伤害-20%`
-        ]
+        messages,
+        targetUpdates: null
       };
     }
-    return null;
-  }, "handlePsychicFrenzy"),
-  // === 宇宙能量 ===
-  handleCosmicEnergy: /* @__PURE__ */ __name(async (ctx, targetBoss, initialDamage, bossGroup) => {
-    if (!targetBoss.skills.includes("宇宙能量")) return null;
-    const maxEnergy = 1e3;
-    const currentEnergy = targetBoss.energy || 0;
-    const availableSpace = maxEnergy - currentEnergy;
-    const energyToAdd = Math.min(initialDamage, availableSpace);
-    const newEnergy = currentEnergy + energyToAdd;
-    let healAmount = 0;
-    let messages = [];
-    if (energyToAdd > 0) {
-      messages.push(`获得${energyToAdd}点能量`);
-    }
-    if (newEnergy >= maxEnergy) {
-      const overflow = initialDamage - energyToAdd;
-      if (overflow > 0) {
-        const maxHP = PassiveHandler.getMemberConfig(targetBoss.name, bossGroup)?.maxHP || 0;
-        if (maxHP > 0) {
-          healAmount = Math.min(overflow, maxHP - targetBoss.HP);
-          messages.push(`能量溢出回复${healAmount}点生命值`);
-        }
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: 1
       }
+    };
+    const newStacks = currentStacks + 1;
+    messages.push(`✨ 【光影之刃】叠加：当前${newStacks}/${maxStacks}层`);
+    return {
+      messages,
+      targetUpdates
+    };
+  }, "handleBladeOfLight"),
+  /** 远古预兆处理（概率免疫能量伤害）- 增加boost参数 */
+  handleAncientOmen: /* @__PURE__ */ __name(function(targetBoss, weaponData, boost = 0) {
+    const messages = [];
+    let isImmune = false;
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("远古预兆")) {
+      return null;
     }
-    if (energyToAdd === 0 && healAmount === 0) {
+    if (weaponData.type !== "能量武器") {
       return null;
     }
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { energy: newEnergy }
-    );
-    return {
-      messages: [`🌌 【宇宙能量】生效：${messages.join("，")}`],
-      healAmount
+    const baseProbability = 0.01;
+    const actualProbability = Math.min(baseProbability + boost, 1);
+    if (Math.random() >= actualProbability) {
+      return null;
+    }
+    isImmune = true;
+    const energyGained = 100;
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        energyChange: energyGained
+        // 回复100点能量
+      }
     };
-  }, "handleCosmicEnergy"),
-  // === 光影之刃 ===
-  handleLightblade: /* @__PURE__ */ __name(async (ctx, targetBoss) => {
-    if (!targetBoss.skills.includes("光影之刃")) return null;
-    const currentStacks = targetBoss.Skillcountpoints || 0;
-    const newStacks = currentStacks + 1;
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      { Skillcountpoints: newStacks }
-    );
+    messages.push(`🔮 【远古预兆】生效：${(actualProbability * 100).toFixed(2)}%概率免疫能量武器伤害`);
+    messages.push(`🔮 回复${energyGained}点能量`);
     return {
-      messages: [`✨ 【光影之刃】生效：获得1层“光影之刃”`]
+      isImmune,
+      messages,
+      targetUpdates
     };
-  }, "handleLightblade"),
-  // === 远古预兆 ===
-  handleAncientOmen: /* @__PURE__ */ __name(async (ctx, targetBoss) => {
-    if (!targetBoss.skills.includes("远古预兆")) return null;
-    let lightbladeStacks = 0;
-    if (targetBoss.skills.includes("闪电冲锋")) {
-      lightbladeStacks = targetBoss?.Skillcountpoints || 0;
-    }
-    const totalChance = 1 + lightbladeStacks;
-    if (Math.random() * 100 < totalChance) {
-      const maxEnergy = 1e3;
-      const currentEnergy = targetBoss.energy || 0;
-      const newEnergy = Math.min(currentEnergy + 100, maxEnergy);
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { energy: newEnergy }
-      );
-      return {
-        immune: true,
-        messages: [
-          `🔮 【远古预兆】生效：免疫此次伤害，并且回复100点能量`
-        ]
-      };
-    }
-    return null;
   }, "handleAncientOmen"),
-  // === 超视距穿梭 ===
-  handleHyperspaceSkip: /* @__PURE__ */ __name(function(targetBoss) {
-    if (!targetBoss.skills.includes("超视距穿梭")) return null;
-    const maxEnergy = 1e3;
+  /** 闪电冲锋处理（提升其他技能概率） - 修正版 */
+  handleLightningCharge: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let ancientOmenBoost = 0;
+    let psychicForgeBoost = 0;
+    if (!targetBoss.skills.includes("闪电冲锋")) {
+      return null;
+    }
+    const lightBladeStacks = targetBoss.skillStacks || 0;
+    const boostPerStack = 5e-3;
+    const totalBoost = lightBladeStacks * boostPerStack;
+    ancientOmenBoost = totalBoost;
+    psychicForgeBoost = totalBoost;
+    if (totalBoost > 0) {
+      messages.push(`⚡ 【闪电冲锋】生效：每层光影之刃提升0.5%概率`);
+      messages.push(`    → 当前${lightBladeStacks}层，远古预兆+${(ancientOmenBoost * 100).toFixed(1)}%，灵能构造炉+${(psychicForgeBoost * 100).toFixed(1)}%`);
+    }
+    return { ancientOmenBoost, psychicForgeBoost, messages };
+  }, "handleLightningCharge"),
+  /** 超视距穿梭处理（层数相关伤害调整） */
+  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 lightbladeStacks = targetBoss.Skillcountpoints || 0;
-    let reduction = 0;
-    let increase = 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, boost = 0) {
     const messages = [];
-    if (currentEnergy <= maxEnergy * 0.1) {
-      increase = lightbladeStacks * 0.05;
-      messages.push(`能量≤10%：受到的伤害+${(increase * 100).toFixed(0)}%`);
-    } else if (currentEnergy >= maxEnergy * 0.6) {
-      reduction = lightbladeStacks * 0.1;
-      messages.push(`能量≥60%：受到的伤害-${(reduction * 100).toFixed(0)}%`);
-    } else if (currentEnergy >= maxEnergy * 0.3) {
-      reduction = lightbladeStacks * 0.05;
-      messages.push(`能量≥30%：受到的伤害-${(reduction * 100).toFixed(0)}%`);
-    }
-    if (reduction > 0 || increase > 0) {
-      return {
-        reduction,
-        increase,
-        messages: [
-          `🚀 【超视距穿梭】生效：${messages.join(" | ")} (当前${lightbladeStacks}层光影之刃)`
-        ]
-      };
+    let newSkill = null;
+    let targetUpdates = null;
+    const possibleSkills = [
+      "天启超载护盾",
+      "塌缩脉冲",
+      "地毯式轰炸",
+      "轰炸引导"
+    ];
+    if (!targetBoss.skills.includes("灵能构造炉")) {
+      return null;
     }
-    return null;
-  }, "handleHyperspaceSkip"),
-  // === 复苏 ===
-  handleRevival: /* @__PURE__ */ __name(async function(ctx, targetBoss, currentHP, maxHP) {
-    if (!targetBoss.skills.includes("复苏") || currentHP > 0) return null;
-    const updatedHP = maxHP * 0.5;
-    const maxEnergy = 1e3;
-    let newSkills = targetBoss.skills;
-    if (!newSkills.includes("灵能构造炉")) {
-      newSkills = [...newSkills, "灵能构造炉"];
-    }
-    newSkills = newSkills.filter((skill) => skill !== "复苏");
-    await ctx.database.set(
-      "ggcevo_boss",
-      { name: targetBoss.name },
-      {
-        HP: updatedHP,
-        energy: maxEnergy,
-        skills: newSkills
-      }
+    const baseProbability = 0.05;
+    const actualProbability = Math.min(baseProbability + boost, 1);
+    if (Math.random() >= actualProbability) {
+      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(`⚙️ 【灵能构造炉】生效：${(actualProbability * 100).toFixed(2)}%概率获得新技能「${newSkill}」`);
     return {
-      updatedHP,
-      messages: [
-        `🔥 【复苏】生效：免于死亡，回复自身50%的最大生命值和100%的“能量”，并且获得新技能【灵能构造炉】`
-      ]
+      messages,
+      newSkill,
+      targetUpdates
     };
-  }, "handleRevival"),
-  // === 灵能构造炉 ===
-  handleConstructor: /* @__PURE__ */ __name(async function(ctx, targetBoss) {
-    if (!targetBoss.skills.includes("灵能构造炉")) return null;
-    const allSkills = ["天启超载护盾", "塌缩脉冲", "地毯式轰炸", "轰炸引导"];
-    const hasAllSkills = allSkills.every((skill) => targetBoss.skills.includes(skill));
-    if (hasAllSkills) {
-      const newSkills = targetBoss.skills.filter((skill) => skill !== "灵能构造炉");
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { skills: newSkills }
-      );
-      return {
-        messages: [
-          `⚙️ 【灵能构造炉】生效：所有技能已获取完毕，此技能已移除`
-        ]
-      };
-    }
-    let lightbladeStacks = 0;
-    if (targetBoss.skills.includes("闪电冲锋")) {
-      lightbladeStacks = targetBoss.Skillcountpoints || 0;
+  }, "handlePsychicForge"),
+  /** 天启超载护盾处理（层数相关群体回复） */
+  handleOverdriveShield: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+    const messages = [];
+    const otherUpdates = [];
+    if (!targetBoss.skills.includes("天启超载护盾")) {
+      return null;
     }
-    const totalChance = 1 + lightbladeStacks;
-    if (Math.random() * 100 < totalChance) {
-      const availableSkills = allSkills.filter(
-        (skill) => !targetBoss.skills.includes(skill)
-      );
-      if (availableSkills.length === 0) return null;
-      const randomSkill = availableSkills[Math.floor(Math.random() * availableSkills.length)];
-      const newSkills = [...targetBoss.skills, randomSkill];
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { skills: newSkills }
-      );
-      return {
-        messages: [
-          `⚙️ 【灵能构造炉】生效：获得新技能【${randomSkill}】`
-        ]
-      };
+    if (Math.random() >= 0.05) {
+      return null;
     }
-    return null;
-  }, "handleConstructor"),
-  // 修改后 - 移除了层数清零操作
-  handleTyrsShield: /* @__PURE__ */ __name(async function(ctx, targetBoss, currentHP, activeBosses, bossGroup) {
-    if (!targetBoss.skills.includes("天启超载护盾")) return null;
-    const lightbladeStacks = targetBoss.Skillcountpoints || 0;
-    if (lightbladeStacks === 0) return null;
-    const triggerChance = 5;
-    if (Math.random() * 100 < triggerChance) {
-      const groupMembers = activeBosses.filter(
-        (b) => b.groupId === targetBoss.groupId && b.HP > 0
-      );
-      const healPerStack = 10;
-      const totalHeal = lightbladeStacks * healPerStack;
-      const updates = [];
-      const messages = [`🛡️ 【天启超载护盾】生效：治疗所有存活异形`];
-      let updatedHP = currentHP;
-      for (const member of groupMembers) {
-        const memberConfig = PassiveHandler.getMemberConfig(member.name, bossGroup);
-        if (!memberConfig) continue;
-        const maxMemberHP = memberConfig.maxHP;
-        const actualHeal = Math.min(totalHeal, maxMemberHP - member.HP);
-        if (actualHeal <= 0) continue;
-        const newHP = member.HP + actualHeal;
-        updates.push(
-          ctx.database.set(
-            "ggcevo_boss",
-            { name: member.name },
-            { HP: newHP }
-          )
-        );
-        messages.push(`${member.name} +${actualHeal}HP`);
-        if (member.name === targetBoss.name) {
-          updatedHP = newHP;
-        }
-      }
-      if (updates.length === 0) {
-        return null;
-      }
-      await Promise.all(updates);
-      return {
-        messages,
-        updatedHP
-        // 返回当前目标的新HP（如果被治疗）
-      };
+    const baseHealAmount = (targetBoss.skillStacks || 0) * 10;
+    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}点生命值`);
+    });
+    messages.unshift(`🛡️ 【天启超载护盾】生效：5%概率触发，为所有存活异形回复生命值`);
+    return {
+      messages,
+      otherUpdates
+    };
+  }, "handleOverdriveShield"),
+  /** 塌缩脉冲处理（额外叠加层数） */
+  handleCollapsingPulse: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    const maxStacks = 50;
+    if (!targetBoss.skills.includes("塌缩脉冲")) {
+      return null;
     }
-    return null;
-  }, "handleTyrsShield"),
-  // === 塌缩脉冲 ===
-  handleCollapsePulse: /* @__PURE__ */ __name(async function(ctx, targetBoss) {
-    if (!targetBoss.skills.includes("塌缩脉冲")) return null;
-    const triggerChance = 100;
-    if (Math.random() * 100 < triggerChance) {
-      const currentStacks = targetBoss.Skillcountpoints || 0;
-      const newStacks = currentStacks + 1;
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { Skillcountpoints: newStacks }
-      );
+    const currentStacks = targetBoss.skillStacks || 0;
+    if (currentStacks >= maxStacks) {
+      messages.push(`🌀 【塌缩脉冲】生效：层数已达上限(${maxStacks})`);
       return {
-        messages: [`💥 【塌缩脉冲】生效：额外获得1层光影之刃`]
+        messages,
+        targetUpdates: null
       };
     }
-    return null;
-  }, "handleCollapsePulse"),
-  // === 地毯式轰炸 ===
-  handleCarpetBombing: /* @__PURE__ */ __name(async function(ctx, targetBoss) {
-    if (!targetBoss.skills.includes("地毯式轰炸")) return null;
-    const triggerChance = 100;
-    const messages = [];
-    let damageMultiplier = 0;
-    if (Math.random() * 100 < triggerChance) {
-      const hasLoneWolf = targetBoss.skills.includes("孤立无援");
-      if (hasLoneWolf) {
-        const newSkills = targetBoss.skills.filter((skill) => skill !== "孤立无援");
-        await ctx.database.set(
-          "ggcevo_boss",
-          { name: targetBoss.name },
-          { skills: newSkills }
-        );
-        messages.push(`🔥 【地毯式轰炸】生效：移除“孤立无援”`);
-      } else {
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        skillStacksChanged: 1
       }
-      damageMultiplier = -1;
-      messages.push(`🔥 【地毯式轰炸】生效：我心中的怒火胜过千万个太阳！受到的伤害-100%`);
-    }
+    };
+    const newStacks = currentStacks + 1;
+    messages.push(`🌀 【塌缩脉冲】生效：额外叠加1层光影之刃，当前${newStacks}/${maxStacks}层`);
     return {
       messages,
-      damageMultiplier
+      targetUpdates
     };
+  }, "handleCollapsingPulse"),
+  /** 地毯式轰炸处理 */
+  handleCarpetBombing: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let nerfMultiplier = 0;
+    if (!targetBoss.skills.includes("地毯式轰炸")) {
+      return null;
+    }
+    nerfMultiplier = 1;
+    messages.push(`💣 【地毯式轰炸】生效：获得100%减伤`);
+    return { nerfMultiplier, messages };
   }, "handleCarpetBombing"),
-  // 修改后 - 移除了层数清零操作
-  handleBombardmentGuidance: /* @__PURE__ */ __name(async function(ctx, targetBoss) {
-    if (!targetBoss.skills.includes("轰炸引导")) return null;
-    const lightbladeStacks = targetBoss.Skillcountpoints || 0;
-    if (lightbladeStacks === 0) return null;
-    const triggerChance = 10;
-    if (Math.random() * 100 < triggerChance) {
-      const energyGain = lightbladeStacks * 50;
-      const maxEnergy = 1e3;
-      const currentEnergy = targetBoss.energy || 0;
-      const newEnergy = Math.min(currentEnergy + energyGain, maxEnergy);
-      await ctx.database.set(
-        "ggcevo_boss",
-        { name: targetBoss.name },
-        { energy: newEnergy }
-      );
-      return {
-        messages: [
-          `🎯 【轰炸引导】生效：回复${energyGain}点能量`
-        ]
-      };
+  /** 轰炸引导处理（层数相关能量回复） */
+  handleBombardmentGuide: /* @__PURE__ */ __name(function(targetBoss) {
+    const messages = [];
+    let targetUpdates = null;
+    if (!targetBoss.skills.includes("轰炸引导")) {
+      return null;
     }
-    return null;
-  }, "handleBombardmentGuidance"),
-  // 修改后的伤害处理函数
-  handlePassives: /* @__PURE__ */ __name(async function(ctx, handle, targetBoss, initialDamage, currentHP, maxHP, weaponName, weaponData, bossGroup) {
-    let messages = [];
-    let skillUpdates = [];
-    let buffMultiplier = 0;
-    let nerfMultiplier = 0;
-    let radiationApplied = false;
-    let freezing = false;
-    let pulseApplied = false;
-    let arcApplied = false;
-    let bileStacks = 0;
-    const activeBosses = await ctx.database.get("ggcevo_boss", { isActive: true });
-    const solarFlareResult = await this.handleSolarFlare(ctx, targetBoss, weaponName);
-    if (solarFlareResult.immune) {
-      return {
-        currentHP: targetBoss.HP,
-        messages: solarFlareResult.messages,
-        skillUpdates: [],
-        initialDamage: 0
-      };
+    if (Math.random() >= 0.05) {
+      return null;
     }
-    const frostEvoResult = this.handleFrostEvolution(targetBoss, weaponName, initialDamage, maxHP);
-    if (frostEvoResult) {
-      return {
-        currentHP: frostEvoResult.updatedHP,
-        messages: frostEvoResult.messages,
-        skillUpdates,
-        initialDamage: 0
+    const currentStacks = targetBoss.skillStacks || 0;
+    const energyGained = currentStacks * 50;
+    targetUpdates = {
+      name: targetBoss.name,
+      updates: {
+        energyChange: energyGained
+      }
+    };
+    messages.push(`🎯 【轰炸引导】生效：5%概率触发，获得${energyGained}点能量（基于${currentStacks}层光影之刃）`);
+    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) {
+        messages.push(`☢️ 注意：超过20层的辐射无效，不会提供额外增伤`);
+      }
+    }
+    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层"辐射"效果，累计${newLayers}层`);
+      layerAdded = true;
     }
-    const coldImmunityResult = this.handleColdAdaptationImmunity(targetBoss, weaponName);
-    if (coldImmunityResult) {
-      return {
-        currentHP,
-        messages: coldImmunityResult.messages,
-        skillUpdates,
-        initialDamage: 0
+    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) {
+        messages.push(`❄️ 注意：超过20层的寒冷无效，不会提供额外增伤`);
+      }
+    }
+    let targetUpdates = null;
+    if (weaponName === "零度之下") {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          coldLayersChange: 1
+          // 寒冷层数增加1
+        }
       };
+      const newLayers = currentLayers + 1;
+      messages.push(`❄️ 满足寒冷条件，获得1层"寒冷"效果，累计${newLayers}层`);
+      layerAdded = true;
     }
-    const fieldResult = await this.handleEnergyField(ctx, targetBoss, weaponName, initialDamage);
-    if (fieldResult) {
-      messages.push(...fieldResult.messages);
-      if (fieldResult.immune) {
-        return {
-          currentHP: targetBoss.HP,
-          messages,
-          skillUpdates,
-          initialDamage: 0
-        };
-      }
+    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 fireEvoResult = await this.handleFireEvolution(
-      ctx,
-      targetBoss,
-      weaponName,
-      initialDamage,
-      bossGroup
-    );
-    if (fireEvoResult) {
-      return {
-        currentHP: fireEvoResult.updatedHP,
-        messages: fireEvoResult.messages,
-        skillUpdates: [],
-        initialDamage: fireEvoResult.initialDamage,
-        bileStacks: fireEvoResult.bileStacks
+    const messages = [];
+    const success = drainValue > 0;
+    let targetUpdates = null;
+    if (success) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          energyChange: -drainValue
+          // 消耗能量（负值）
+        }
       };
     }
-    const criticalResult = this.handleCriticalHit(targetBoss, initialDamage);
-    if (criticalResult?.immune) {
-      return {
-        currentHP: targetBoss.HP,
-        messages: criticalResult.messages,
-        skillUpdates: [],
-        initialDamage: 0
-      };
+    const weaponDisplayName = weaponName === "弧焊枪" ? "弧焊枪" : "DG-3电弧步枪";
+    if (success) {
+      messages.push(`⚡ 【${weaponDisplayName}】武器效果：消耗目标${drainValue}点能量`);
     }
-    const hunterImmune = await this.handleHunterAlien(targetBoss, weaponName, activeBosses);
-    if (hunterImmune?.immune) {
-      return {
-        currentHP: targetBoss.HP,
-        messages: hunterImmune.messages,
-        skillUpdates: [],
-        initialDamage: 0
-      };
+    return {
+      messages,
+      targetUpdates,
+      success
+    };
+  }, "handleWeaponEnergyDrain"),
+  // 统一的武器层数减少处理函数
+  handleWeaponLayerReduction: /* @__PURE__ */ __name(function(targetBoss, weaponName) {
+    const weaponLayerReduction = {
+      "脉冲扰乱枪": 2
+      // 可以在这里添加其他武器及其减少层数
+    };
+    const reductionAmount = weaponLayerReduction[weaponName];
+    if (!reductionAmount) {
+      return null;
     }
-    const ancientOmenResult = await this.handleAncientOmen(ctx, targetBoss);
-    if (ancientOmenResult?.immune) {
-      return {
-        currentHP: targetBoss.HP,
-        messages: ancientOmenResult.messages,
-        skillUpdates: [],
-        initialDamage: 0
+    const messages = [];
+    const reductionSuccess = reductionAmount > 0;
+    let targetUpdates = null;
+    if (reductionSuccess) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          skillStacksChanged: -reductionAmount
+          // 减少层数
+        }
       };
     }
-    targetBoss.skills.forEach((skill) => {
-      const config = passiveConfig[skill];
-      if (config && config.effect !== void 0 && config.effect !== 0) {
-        if (config.effect > 0) {
-          buffMultiplier += config.effect;
-        } else {
-          nerfMultiplier += config.effect;
+    if (reductionSuccess) {
+      messages.push(`⚡ 【${weaponName}】武器效果：使${targetBoss.name}的技能层数减少${reductionAmount}层`);
+    }
+    return {
+      messages,
+      targetUpdates,
+      reductionSuccess
+    };
+  }, "handleWeaponLayerReduction")
+};
+function applyPassiveEffects(targetBoss, weaponName, damage, activeBosses) {
+  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 ancientOmenBoost = 0;
+  let psychicForgeBoost = 0;
+  let doubleAstralWind = false;
+  const lightningResult = BattleEffectProcessor.handleLightningCharge(targetBoss);
+  if (lightningResult) {
+    messages.push(...lightningResult.messages);
+    ancientOmenBoost += lightningResult.ancientOmenBoost || 0;
+    psychicForgeBoost += lightningResult.psychicForgeBoost || 0;
+  }
+  const coldImmuneEffects = [
+    BattleEffectProcessor.handleFrostEvolution,
+    BattleEffectProcessor.handleColdAdaptation,
+    BattleEffectProcessor.handleSolarFlare
+  ];
+  const fireImmuneEffects = [
+    BattleEffectProcessor.handleFlameAlien
+  ];
+  if (weaponName === "零度之下") {
+    for (const effect of coldImmuneEffects) {
+      const result = effect(targetBoss, weaponName, damage, activeBosses);
+      if (result && result.isImmune) {
+        immune = true;
+        messages.push(...result.messages);
+        if (result.targetUpdates) {
+          updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
         }
-        const effectPercent = Math.round(config.effect * 100);
-        const effectSign = config.effect > 0 ? "+" : "";
-        messages.push(`📚 【${skill}】生效：受到的伤害${effectSign}${effectPercent}%`);
       }
-    });
-    const radiationCalc = this.calculateRadiationDamage(targetBoss);
-    if (radiationCalc) {
-      buffMultiplier += radiationCalc.damageMultiplier;
-      messages.push(...radiationCalc.messages);
-    }
-    const coldDamageResult = this.calculateColdDamage(targetBoss);
-    if (coldDamageResult) {
-      buffMultiplier += coldDamageResult.damageMultiplier;
-      messages.push(...coldDamageResult.messages);
-    }
-    const infectionResult = await this.handleInfectedStation(ctx, targetBoss);
-    if (infectionResult) {
-      nerfMultiplier += infectionResult.damageMultiplier;
-      messages.push(...infectionResult.messages);
-    }
-    const armorResult = this.handleStructuralArmor(targetBoss, weaponData);
-    if (armorResult) {
-      nerfMultiplier += armorResult.damageMultiplier;
-      messages.push(...armorResult.messages);
-    }
-    const bloodEffect = this.handleBloodEffects(targetBoss, currentHP, maxHP);
-    if (bloodEffect) {
-      if (bloodEffect.buffAmount > 0) {
-        buffMultiplier += bloodEffect.buffAmount;
-      }
-      if (bloodEffect.nerfAmount > 0) {
-        nerfMultiplier -= bloodEffect.nerfAmount;
-      }
-      messages.push(...bloodEffect.messages);
-    }
-    const siphonResult = this.handleEnergySiphon(targetBoss, currentHP, maxHP);
-    if (siphonResult) {
-      nerfMultiplier += siphonResult.damageMultiplier;
-      messages.push(...siphonResult.messages);
-    }
-    const powerSiphonResult = this.handlePowerSiphon(targetBoss);
-    if (powerSiphonResult) {
-      nerfMultiplier += powerSiphonResult.damageMultiplier;
-      messages.push(...powerSiphonResult.messages);
-    }
-    const giantRageResult = this.handleGiantRage(targetBoss, currentHP, maxHP);
-    if (giantRageResult) {
-      nerfMultiplier += giantRageResult.damageMultiplier;
-      messages.push(...giantRageResult.messages);
-    }
-    const hellfireBombResult = this.handleHellfireBomb(targetBoss, activeBosses);
-    if (hellfireBombResult) {
-      nerfMultiplier += hellfireBombResult.damageMultiplier;
-      messages.push(...hellfireBombResult.messages);
-    }
-    const disguiseResult = await this.handleDisguise(ctx, targetBoss, weaponName, initialDamage);
-    if (disguiseResult) {
-      nerfMultiplier += disguiseResult.damageMultiplier;
-      messages.push(...disguiseResult.messages);
-    }
-    if (hunterImmune && !hunterImmune.immune) {
-      const multiplier = hunterImmune.damageMultiplier;
-      if (multiplier > 0) {
-        buffMultiplier += multiplier;
-      } else {
-        nerfMultiplier += multiplier;
-      }
-      messages.push(...hunterImmune.messages);
     }
-    const rageResult = this.handleRage(targetBoss, currentHP, maxHP);
-    if (rageResult) {
-      nerfMultiplier += rageResult.damageMultiplier;
-      messages.push(...rageResult.messages);
+  }
+  if (weaponName === "焚烧枪") {
+    for (const effect of fireImmuneEffects) {
+      const result = effect(targetBoss, weaponName, damage);
+      if (result && result.isImmune) {
+        immune = true;
+        messages.push(...result.messages);
+        if (result.targetUpdates) {
+          updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
+        }
+      }
     }
-    const hyperspaceResult = this.handleHyperspaceSkip(targetBoss);
-    if (hyperspaceResult) {
-      if (hyperspaceResult.reduction > 0) {
-        nerfMultiplier -= hyperspaceResult.reduction;
+  }
+  const chanceImmuneEffects = [
+    BattleEffectProcessor.handleDeadlyHit,
+    BattleEffectProcessor.handleElectricField,
+    BattleEffectProcessor.handleAncientOmen
+  ];
+  for (const effect of chanceImmuneEffects) {
+    if (effect === BattleEffectProcessor.handleAncientOmen) {
+      const result = effect(targetBoss, weaponData, ancientOmenBoost);
+      if (result && result.isImmune) {
+        immune = true;
+        messages.push(...result.messages);
+        if (result.targetUpdates) {
+          updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
+        }
       }
-      if (hyperspaceResult.increase > 0) {
-        buffMultiplier += hyperspaceResult.increase;
+    } else {
+      const result = effect(targetBoss, weaponData);
+      if (result && result.isImmune) {
+        immune = true;
+        messages.push(...result.messages);
       }
-      messages.push(...hyperspaceResult.messages);
     }
-    const frenzyResult = this.handlePsychicFrenzy(targetBoss, currentHP, maxHP);
-    if (frenzyResult) {
-      nerfMultiplier += frenzyResult.damageMultiplier;
-      messages.push(...frenzyResult.messages);
+  }
+  const damageAdjustEffects = [
+    BattleEffectProcessor.handleWeakForm,
+    BattleEffectProcessor.handleAlienShell,
+    BattleEffectProcessor.handleIsolated,
+    BattleEffectProcessor.handleFrostHell,
+    BattleEffectProcessor.handleStressShellI,
+    BattleEffectProcessor.handleStressShellII,
+    BattleEffectProcessor.handleInfectedSpaceStation,
+    BattleEffectProcessor.handleVirusCloud,
+    BattleEffectProcessor.handleStructuralArmor,
+    BattleEffectProcessor.handleVampireSaliva,
+    BattleEffectProcessor.handleBloodlust,
+    BattleEffectProcessor.handleVomit,
+    BattleEffectProcessor.handleEnergySiphon,
+    BattleEffectProcessor.handleEnergyAbsorption,
+    BattleEffectProcessor.handleEnergyBlackhole,
+    BattleEffectProcessor.handleColossalRampage,
+    BattleEffectProcessor.handleInfernalBomb,
+    BattleEffectProcessor.handleHunterAlien,
+    BattleEffectProcessor.handleRampage,
+    BattleEffectProcessor.handleDisguise,
+    BattleEffectProcessor.handleHyperRangeShift,
+    BattleEffectProcessor.handleCarpetBombing
+  ];
+  for (const effect of damageAdjustEffects) {
+    let result;
+    if (effect === BattleEffectProcessor.handleIsolated || effect === BattleEffectProcessor.handleInfectedSpaceStation || effect === BattleEffectProcessor.handleInfernalBomb || effect === BattleEffectProcessor.handleHunterAlien) {
+      result = effect(targetBoss, activeBosses, weaponName);
+    } else if (effect === BattleEffectProcessor.handleStructuralArmor) {
+      result = effect(targetBoss, weaponData);
+    } else if (effect === BattleEffectProcessor.handleBloodlust || effect === BattleEffectProcessor.handleVampireSaliva || effect === BattleEffectProcessor.handleHyperRangeShift) {
+      result = effect(targetBoss, activeBosses);
+    } else {
+      result = effect(targetBoss, activeBosses, weaponName);
     }
-    const bombingResult = await this.handleCarpetBombing(ctx, targetBoss);
-    if (bombingResult) {
-      nerfMultiplier += bombingResult.damageMultiplier;
-      messages.push(...bombingResult.messages);
+    if (result) {
+      messages.push(...result.messages);
+      if (result.buffMultiplier !== void 0 && typeof result.buffMultiplier === "number") {
+        totalBuffMultiplier += result.buffMultiplier;
+      }
+      if (result.nerfMultiplier !== void 0 && typeof result.nerfMultiplier === "number") {
+        totalNerfMultiplier += result.nerfMultiplier;
+      }
     }
-    if (solarFlareResult.messages.length > 0) {
-      messages.push(...solarFlareResult.messages);
+  }
+  const stateChangeEffects = [
+    BattleEffectProcessor.handleVampireSaliva,
+    BattleEffectProcessor.handleBladeOfLight,
+    BattleEffectProcessor.handleSuperconductor
+  ];
+  for (const effect of stateChangeEffects) {
+    const result = effect(targetBoss);
+    if (result) {
+      messages.push(...result.messages);
+      if (result.targetUpdates) {
+        updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
+      }
     }
-    let baseMultiplier = buffMultiplier + nerfMultiplier;
-    const ignoreReductionResult = await this.handleIgnoreReductionEffects(
-      ctx,
-      handle,
-      weaponName,
-      targetBoss,
-      nerfMultiplier
-      // 只传入减伤部分
-    );
-    let effectiveMultiplier = baseMultiplier;
-    let appliedIgnoreMessages = [];
-    let effectiveNerf = nerfMultiplier;
-    if (ignoreReductionResult) {
-      appliedIgnoreMessages = ignoreReductionResult.messages;
-      effectiveNerf = nerfMultiplier * (1 - ignoreReductionResult.ignoreRate);
-      effectiveMultiplier = buffMultiplier + effectiveNerf;
-    }
-    const originalMultiplier = effectiveMultiplier;
-    if (originalMultiplier < -1) {
-      messages.push(`⚠️ 触发伤害保底机制：强制造成1点伤害`);
-    }
-    let finalDamage = initialDamage * (1 + effectiveMultiplier);
-    finalDamage = Math.floor(finalDamage);
-    finalDamage = Math.max(finalDamage, 1);
-    currentHP = targetBoss.HP - finalDamage;
-    if (currentHP < 0) {
-      currentHP = 0;
-    }
-    if (appliedIgnoreMessages.length > 0) {
-      messages.push(...appliedIgnoreMessages);
-      messages.push(
-        `⚡ 减伤效果：${(nerfMultiplier * 100).toFixed(0)}% → ${(effectiveNerf * 100).toFixed(0)}%`
-      );
+  }
+  const burningSlimeResult = BattleEffectProcessor.handleBurningSlime(targetBoss, weaponName);
+  if (burningSlimeResult) {
+    messages.push(...burningSlimeResult.messages);
+    if (burningSlimeResult.targetUpdates) {
+      updateStatsByName(burningSlimeResult.targetUpdates.name, burningSlimeResult.targetUpdates.updates);
     }
-    if (currentHP <= 0 && !targetBoss.skills.includes("求生本能I") && !targetBoss.skills.includes("求生本能II") && !targetBoss.skills.includes("复苏")) {
-      return {
-        currentHP,
-        messages,
-        skillUpdates,
-        initialDamage: finalDamage,
-        radiationApplied,
-        freezing
-      };
+    bileDetonationTrigger = burningSlimeResult.isHighStackHeal;
+  }
+  const healingEffects = [
+    BattleEffectProcessor.handleFrostRegeneration,
+    BattleEffectProcessor.handleFrostAura,
+    BattleEffectProcessor.handleSurvivalInstinctI,
+    BattleEffectProcessor.handleSurvivalInstinctII,
+    BattleEffectProcessor.handleSentryGun,
+    BattleEffectProcessor.handleFeeding,
+    BattleEffectProcessor.handleMoldGrowth,
+    BattleEffectProcessor.handleElectricShockwave,
+    BattleEffectProcessor.handlePulse,
+    BattleEffectProcessor.handleCorrosiveBile,
+    BattleEffectProcessor.handleFlameBreath,
+    BattleEffectProcessor.handleBurningBurrow,
+    BattleEffectProcessor.handleRevival,
+    BattleEffectProcessor.handleCosmicEnergy,
+    BattleEffectProcessor.handleBombardmentGuide,
+    BattleEffectProcessor.handleOverdriveShield
+  ];
+  for (const effect of healingEffects) {
+    let result;
+    if (effect === BattleEffectProcessor.handleFrostRegeneration || effect === BattleEffectProcessor.handleFrostAura || effect === BattleEffectProcessor.handlePulse || effect === BattleEffectProcessor.handleSentryGun || effect === BattleEffectProcessor.handleCorrosiveBile || effect === BattleEffectProcessor.handleFlameBreath || effect === BattleEffectProcessor.handleOverdriveShield) {
+      result = effect(targetBoss, activeBosses, damage);
+    } else if (effect === BattleEffectProcessor.handleCosmicEnergy) {
+      result = effect(targetBoss, activeBosses, damage);
+    } else {
+      result = effect(targetBoss, activeBosses, damage);
     }
-    const frostSurroundResult = await this.handleFrostSurround(ctx, targetBoss, currentHP, maxHP);
-    if (frostSurroundResult) {
-      currentHP = frostSurroundResult.updatedHP;
-      messages.push(...frostSurroundResult.messages);
-      skillUpdates.push(...frostSurroundResult.skillUpdates);
-    }
-    const frostRecoveryResult = await this.handleFrostRecovery(ctx, targetBoss, currentHP, maxHP, activeBosses, bossGroup);
-    if (frostRecoveryResult) {
-      currentHP = frostRecoveryResult.updatedHP;
-      messages.push(...frostRecoveryResult.messages);
-      skillUpdates.push(...frostRecoveryResult.skillUpdates);
-    }
-    const burningBurrowResult = await this.handleBurningBurrow(ctx, targetBoss, currentHP, maxHP);
-    if (burningBurrowResult) {
-      currentHP = burningBurrowResult.updatedHP;
-      messages.push(...burningBurrowResult.messages);
-      skillUpdates.push(...burningBurrowResult.skillUpdates);
-    }
-    const moldResult = await this.handleMoldGrowth(ctx, targetBoss, bossGroup);
-    if (moldResult) {
-      messages.push(...moldResult.messages);
-    }
-    const pulseResult = await this.handlePulse(
-      ctx,
-      targetBoss,
-      activeBosses,
-      bossGroup,
-      currentHP
-      // 传入当前HP值
-    );
-    if (pulseResult) {
-      currentHP = pulseResult.newHP;
-      messages.push(...pulseResult.messages);
-    }
-    let skipBileStacking = false;
-    if (weaponName !== "焚烧枪") {
-      if (targetBoss.skills.includes("腐蚀胆汁")) {
-        const bileTriggered = await this.handleCorrosiveBile(ctx, targetBoss, bossGroup, currentHP);
-        if (bileTriggered) {
-          currentHP = bileTriggered.currentHP;
-          skipBileStacking = true;
-          messages.push(...bileTriggered.messages);
-        }
+    if (result) {
+      messages.push(...result.messages);
+      if (result.targetUpdates) {
+        updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
       }
-      if (targetBoss.skills.includes("火焰吐息")) {
-        const breathTriggered = await this.handleFireBreath(ctx, targetBoss, bossGroup, currentHP);
-        if (breathTriggered) {
-          currentHP = breathTriggered.currentHP;
-          skipBileStacking = true;
-          messages.push(...breathTriggered.messages);
+      if (result.otherUpdates) {
+        for (const update of result.otherUpdates) {
+          updateStatsByName(update.name, update.updates);
         }
       }
     }
-    const stellarWindResult = await this.handleStellarWind(ctx, targetBoss, initialDamage, currentHP, maxHP, activeBosses, bossGroup);
-    if (stellarWindResult) {
-      currentHP = stellarWindResult.updatedHP;
-      messages.push(...stellarWindResult.messages);
-    }
-    const shieldResult = await this.handleTyrsShield(ctx, targetBoss, currentHP, activeBosses, bossGroup);
-    if (shieldResult) {
-      currentHP = shieldResult.updatedHP;
-      messages.push(...shieldResult.messages);
-    }
-    const survivalResult = this.handleSurvivalInstinct(targetBoss, currentHP, maxHP);
-    if (survivalResult) {
-      currentHP = survivalResult.updatedHP;
-      messages.push(...survivalResult.messages);
-      skillUpdates.push(...survivalResult.skillUpdates);
-    }
-    const revivalResult = await this.handleRevival(ctx, targetBoss, currentHP, maxHP);
-    if (revivalResult) {
-      currentHP = revivalResult.updatedHP;
-      messages.push(...revivalResult.messages);
-    }
-    const pulseDisruptorResult = await this.handlePulseDisruptor(
-      ctx,
-      targetBoss,
-      weaponName
-    );
-    if (pulseDisruptorResult) {
-      messages.push(...pulseDisruptorResult.messages);
-      pulseApplied = pulseDisruptorResult.pulseApplied;
-    }
-    const arcResult = await this.handleArcWelderEffect(ctx, targetBoss, weaponName);
-    if (arcResult) {
-      messages.push(...arcResult.messages);
-      arcApplied = arcResult.arcApplied;
-    }
-    const arcRifleResult = await this.handleArcRifleEffect(ctx, targetBoss, weaponName, messages);
-    if (arcRifleResult) {
-      messages.push(...arcRifleResult.messages);
-    }
-    const coldAdaptResult = await this.handleColdAdaptation(ctx, targetBoss, weaponName);
-    if (coldAdaptResult) {
-      messages.push(...coldAdaptResult.messages);
-    }
-    const bloodCountResult = await this.handleBloodCount(ctx, targetBoss, currentHP, maxHP);
-    if (bloodCountResult) {
-      currentHP = bloodCountResult.updatedHP;
-      messages.push(...bloodCountResult.messages);
+  }
+  const mindFrenzyResult = BattleEffectProcessor.handleMindFrenzy(targetBoss);
+  if (mindFrenzyResult) {
+    messages.push(...mindFrenzyResult.messages);
+    totalNerfMultiplier += mindFrenzyResult.nerfMultiplier || 0;
+    doubleAstralWind = mindFrenzyResult.doubleAstralWind || false;
+  }
+  const radiationResult = BattleEffectProcessor.handleRadiationEffect(targetBoss, weaponName);
+  if (radiationResult) {
+    messages.push(...radiationResult.messages);
+    if (radiationResult.buffMultiplier) {
+      totalBuffMultiplier += radiationResult.buffMultiplier - 1;
     }
-    const sentryResult = await this.handleSentryGun(ctx, targetBoss, bossGroup);
-    if (sentryResult) {
-      messages.push(...sentryResult.messages);
+    if (radiationResult.targetUpdates) {
+      updateStatsByName(radiationResult.targetUpdates.name, radiationResult.targetUpdates.updates);
     }
-    const lightbladeResult = await this.handleLightblade(ctx, targetBoss);
-    if (lightbladeResult) {
-      messages.push(...lightbladeResult.messages);
+    radiationLayerAdded = radiationResult.layerAdded;
+  }
+  const coldResult = BattleEffectProcessor.handleColdEffect(targetBoss, weaponName);
+  if (coldResult) {
+    messages.push(...coldResult.messages);
+    if (coldResult.buffMultiplier) {
+      totalBuffMultiplier += coldResult.buffMultiplier - 1;
     }
-    const CollapsepulseResult = await this.handleCollapsePulse(ctx, targetBoss);
-    if (CollapsepulseResult) {
-      messages.push(...CollapsepulseResult.messages);
+    if (coldResult.targetUpdates) {
+      updateStatsByName(coldResult.targetUpdates.name, coldResult.targetUpdates.updates);
     }
-    const bileStackResult = await this.handleBileStacking(ctx, targetBoss, skipBileStacking);
-    if (bileStackResult) {
-      messages.push(...bileStackResult.messages);
+    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);
     }
-    const shockwaveResult = await this.handleEnergyShockwave(ctx, targetBoss);
-    if (shockwaveResult) {
-      messages.push(...shockwaveResult.messages);
+    energyDrained = energyDrainResult.success;
+  }
+  const layerReduceResult = BattleEffectProcessor.handleWeaponLayerReduction(targetBoss, weaponName);
+  if (layerReduceResult) {
+    messages.push(...layerReduceResult.messages);
+    if (layerReduceResult.targetUpdates) {
+      updateStatsByName(layerReduceResult.targetUpdates.name, layerReduceResult.targetUpdates.updates);
     }
-    const cosmicResult = await this.handleCosmicEnergy(ctx, targetBoss, finalDamage, bossGroup);
-    if (cosmicResult) {
-      messages.push(...cosmicResult.messages);
-      if (cosmicResult.healAmount > 0) {
-        currentHP = Math.min(targetBoss.HP + cosmicResult.healAmount, maxHP);
+    layerReduced = layerReduceResult.reductionSuccess;
+  }
+  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 guidanceResult = await this.handleBombardmentGuidance(ctx, targetBoss);
-    if (guidanceResult) {
-      messages.push(...guidanceResult.messages);
-    }
-    const gammaRadResult = await this.handleGammaRadiation(ctx, targetBoss, weaponName);
-    if (gammaRadResult) {
-      messages.push(...gammaRadResult.messages);
-      radiationApplied = gammaRadResult.radiationApplied;
-    }
-    const coldEffectResult = await this.handleColdEffect(ctx, targetBoss, weaponName);
-    if (coldEffectResult) {
-      messages.push(...coldEffectResult.messages);
-      freezing = coldEffectResult.freezing;
-    }
-    const tagChangeResult = await this.handleConductorTagChange(ctx, targetBoss, currentHP, maxHP);
-    if (tagChangeResult) {
-      messages.push(...tagChangeResult.messages);
-    }
-    const constructorResult = await this.handleConstructor(ctx, targetBoss);
-    if (constructorResult) {
-      messages.push(...constructorResult.messages);
-    }
-    return {
-      currentHP,
-      messages,
-      skillUpdates,
-      initialDamage: finalDamage,
-      radiationApplied,
-      // 新增返回辐射应用标记
-      freezing,
-      pulseApplied,
-      arcApplied
-    };
-  }, "handlePassives"),
-  // 应用技能更新到数据库（优化合并同名boss的更新）
-  applySkillUpdates: /* @__PURE__ */ __name(async (ctx, skillUpdates) => {
-    const mergedUpdates = skillUpdates.reduce((acc, update) => {
-      const existing = acc.find((u) => u.name === update.name);
-      if (existing) {
-        if (update.remove) {
-          existing.remove = [.../* @__PURE__ */ new Set([...existing.remove, ...update.remove])];
-        }
-        if (update.add) {
-          existing.add = [.../* @__PURE__ */ new Set([...existing.add, ...update.add])];
-        }
-      } else {
-        acc.push({
-          name: update.name,
-          remove: [...new Set(update.remove || [])],
-          add: [...new Set(update.add || [])]
-        });
-      }
-      return acc;
-    }, []);
-    const updates = mergedUpdates.map(async (update) => {
-      const [boss] = await ctx.database.get("ggcevo_boss", { name: update.name });
-      if (!boss) return;
-      let newSkills = [...boss.skills];
-      if (update.remove?.length) {
-        newSkills = newSkills.filter((s) => !update.remove.includes(s));
-      }
-      if (update.add?.length) {
-        newSkills = [...newSkills, ...update.add];
-        newSkills = [...new Set(newSkills)];
-      }
-      return ctx.database.set(
-        "ggcevo_boss",
-        { name: update.name },
-        { skills: newSkills }
-      );
-    });
-    await Promise.all(updates);
-  }, "applySkillUpdates")
-};
-
-// src/boss/attackhandling.ts
-function getBossMaxHP(bossName) {
-  for (const bossGroup of bossPool) {
-    if (bossGroup.main.name === bossName) {
-      return bossGroup.main.maxHP;
+  }
+  const psychicForgeResult = BattleEffectProcessor.handlePsychicForge(targetBoss, psychicForgeBoost);
+  if (psychicForgeResult) {
+    messages.push(...psychicForgeResult.messages);
+    if (psychicForgeResult.targetUpdates) {
+      updateStatsByName(psychicForgeResult.targetUpdates.name, psychicForgeResult.targetUpdates.updates);
     }
-    for (const minion of bossGroup.minions) {
-      if (minion.name === bossName) {
-        return minion.maxHP;
-      }
+  }
+  let finalDamage = damage;
+  if (!immune) {
+    const damageMultiplier = 1 + totalBuffMultiplier - totalNerfMultiplier;
+    finalDamage = Math.max(1, Math.round(damage * damageMultiplier));
+    if (damage !== finalDamage) {
+      const adjustmentPercent = ((damageMultiplier - 1) * 100).toFixed(1);
+      if (damageMultiplier > 1) {
+        messages.push(`⚔️ 伤害增益: 总计增加${adjustmentPercent}%伤害`);
+      } else if (damageMultiplier < 1) {
+        messages.push(`🛡️ 伤害减免: 总计减少${Math.abs(Number(adjustmentPercent))}%伤害`);
+      }
+    }
+    if (finalDamage > 0) {
+      updateStatsByName(targetBoss.name, {
+        hpChange: -finalDamage
+      });
     }
   }
-  return 0;
+  if (immune) {
+    finalDamage = 0;
+  }
+  return {
+    finalDamage,
+    messages,
+    radiationLayerAdded,
+    coldLayerAdded,
+    energyDrained,
+    layerReduced,
+    bileDetonationTrigger
+  };
 }
-__name(getBossMaxHP, "getBossMaxHP");
+__name(applyPassiveEffects, "applyPassiveEffects");
+
+// src/boss/attackhandling.ts
 async function getCleanerRewardBroadcast(ctx, boss, killerHandle, killerName) {
-  try {
-    const bossType = boss.type;
-    const bossName = boss.name;
-    const baseReward = bossType === "主宰" ? 10 : 5;
-    const allCleaners = await ctx.database.get("ggcevo_careers", {
-      career: "清洁工"
-    });
-    if (!allCleaners.length) return [];
-    let killerBonus = false;
-    let killerBonusMessage = "";
-    for (const cleaner of allCleaners) {
-      let rewardAmount = baseReward;
-      if (cleaner.handle === killerHandle) {
-        rewardAmount *= 2;
-        killerBonus = true;
-      }
-      await ctx.database.upsert("ggcevo_careers", [{
-        handle: cleaner.handle,
-        redcrystal: (cleaner.redcrystal || 0) + rewardAmount
-      }], ["handle"]);
+  const bossType = boss.type;
+  const bossName = boss.name;
+  const baseReward = bossType === "主宰" ? 10 : 5;
+  const allCleaners = await ctx.database.get("ggcevo_careers", {
+    career: "清洁工"
+  });
+  if (!allCleaners.length) return [];
+  let killerBonus = false;
+  let killerBonusMessage = "";
+  for (const cleaner of allCleaners) {
+    let rewardAmount = baseReward;
+    if (cleaner.handle === killerHandle) {
+      rewardAmount *= 2;
+      killerBonus = true;
     }
-    const rewardMessage = `🧹 全体清洁工因清理 ${bossName} 获得 ${baseReward} 红晶${killerBonus ? ` (致命一击双倍奖励者：${killerName})` : ""}`;
-    return [rewardMessage];
-  } catch (error) {
-    ctx.logger("ggcevo").warn("清洁工奖励发放失败", error);
-    return [];
+    await ctx.database.upsert("ggcevo_careers", [{
+      handle: cleaner.handle,
+      redcrystal: (cleaner.redcrystal || 0) + rewardAmount
+    }], ["handle"]);
   }
+  const rewardMessage = `🧹 清洁工职业因清理 ${bossName} 获得 ${baseReward} 红晶${killerBonus ? ` (致命一击奖励者：${killerName})` : ""}`;
+  return [rewardMessage];
 }
 __name(getCleanerRewardBroadcast, "getCleanerRewardBroadcast");
 async function handleBossDefeatRewards(ctx, targetBoss) {
@@ -4370,42 +4366,30 @@ async function handleBossDefeatRewards(ctx, targetBoss) {
   return { rewardMessages };
 }
 __name(handleBossDefeatRewards, "handleBossDefeatRewards");
-async function handlePrimaryAttack(ctx, session, config, handle, equippedWeapon, targetBoss, activeBosses, bossGroup, weaponName, weaponData, maxHP) {
+async function handlePrimaryAttack(ctx, session, config, equippedWeapon, targetBoss, activeBosses, weaponName) {
   const damageResult = await calculateTotalDamage(ctx, session, config, equippedWeapon, targetBoss);
-  const passiveResult = await PassiveHandler.handlePassives(
-    ctx,
-    handle,
-    targetBoss,
-    damageResult.damage,
-    targetBoss.HP,
-    maxHP,
-    weaponName,
-    weaponData,
-    bossGroup
-  );
-  const currentHP = passiveResult.currentHP;
-  const initialDamage = passiveResult.initialDamage;
-  if (passiveResult.skillUpdates.length > 0) {
-    await PassiveHandler.applySkillUpdates(ctx, passiveResult.skillUpdates);
-  }
+  const EffectProcessor = applyPassiveEffects(targetBoss, weaponName, damageResult.damage, activeBosses);
+  const initialDamage = EffectProcessor.finalDamage;
+  await saveAndClearStats(ctx);
+  const [currentboss] = await ctx.database.get("ggcevo_boss", { name: targetBoss.name });
+  const currentHP = currentboss.HP;
   const isDefeated = currentHP <= 0;
   return {
     initialDamage,
     currentHP,
     isDefeated,
-    damage: initialDamage,
     hasCrit: damageResult.hasCrit,
     effectMessage: damageResult.effectMessage,
-    passiveMessages: passiveResult.messages,
-    radiationApplied: passiveResult.radiationApplied,
-    freezing: passiveResult.freezing,
-    bileStacks: passiveResult.bileStacks,
-    pulseApplied: passiveResult.pulseApplied,
-    arcApplied: passiveResult.arcApplied
+    passiveMessages: EffectProcessor.messages,
+    radiationApplied: EffectProcessor.radiationLayerAdded,
+    freezing: EffectProcessor.coldLayerAdded,
+    bileStacks: EffectProcessor.bileDetonationTrigger,
+    pulseApplied: EffectProcessor.layerReduced,
+    arcApplied: EffectProcessor.energyDrained
   };
 }
 __name(handlePrimaryAttack, "handlePrimaryAttack");
-async function handleScatterAttack(ctx, session, config, handle, equippedWeapon, targetBoss, weaponName, weaponData, activeBosses, bossGroup) {
+async function handleScatterAttack(ctx, session, config, equippedWeapon, targetBoss, weaponName, activeBosses) {
   const secondaryTargets = activeBosses.filter((boss) => boss.name !== targetBoss.name);
   const scatterEffectMessages = [];
   const extraDamages = [];
@@ -4428,47 +4412,32 @@ async function handleScatterAttack(ctx, session, config, handle, equippedWeapon,
       secondaryTarget
     );
     const secondaryDamage = Math.round(damageResult.damage * scatterRatio);
-    const passiveResult = await PassiveHandler.handlePassives(
-      ctx,
-      handle,
-      secondaryTarget,
-      secondaryDamage,
-      secondaryTarget.HP,
-      getBossMaxHP(secondaryTarget.name),
-      weaponName,
-      weaponData,
-      bossGroup
-    );
-    const actualDamage = Math.min(passiveResult.initialDamage, secondaryTarget.HP);
-    const newHP = passiveResult.currentHP;
+    const EffectProcessor = applyPassiveEffects(targetBoss, weaponName, secondaryDamage, activeBosses);
+    const actualDamage = EffectProcessor.finalDamage;
+    await saveAndClearStats(ctx);
+    const [currentboss] = await ctx.database.get("ggcevo_boss", { name: targetBoss.name });
+    const currentHP = currentboss.HP;
     extraDamages.push({
       name: secondaryTarget.name,
       damage: actualDamage
     });
-    if (passiveResult.skillUpdates.length > 0) {
-      await PassiveHandler.applySkillUpdates(ctx, passiveResult.skillUpdates);
-    }
-    if (passiveResult.radiationApplied) {
+    if (EffectProcessor.radiationLayerAdded) {
       taskUpdates.push({ taskId: 1, count: 1 });
     }
-    if (passiveResult.freezing) {
+    if (EffectProcessor.coldLayerAdded) {
       taskUpdates.push({ taskId: 2, count: 1 });
     }
-    if (passiveResult.bileStacks >= 10) {
+    if (EffectProcessor.bileDetonationTrigger) {
       taskUpdates.push({ taskId: 3, count: 1 });
     }
-    if (passiveResult.pulseApplied) {
+    if (EffectProcessor.layerReduced) {
       taskUpdates.push({ taskId: 4, count: 1 });
     }
-    if (passiveResult.arcApplied) {
+    if (EffectProcessor.energyDrained) {
       taskUpdates.push({ taskId: 5, count: 1 });
     }
-    const isDead = newHP <= 0;
-    await ctx.database.set("ggcevo_boss", { name: secondaryTarget.name }, {
-      HP: Math.max(newHP, 0),
-      isActive: !isDead
-    });
-    scatterEffectMessages.push(...passiveResult.messages.map((m) => ` 对 ${secondaryTarget.name} ${m}`));
+    const isDead = currentHP <= 0;
+    scatterEffectMessages.push(...EffectProcessor.messages.map((m) => ` 对 ${secondaryTarget.name} ${m}`));
     if (isDead) {
       actuallyDead.push(secondaryTarget.name);
     }
@@ -4477,26 +4446,10 @@ async function handleScatterAttack(ctx, session, config, handle, equippedWeapon,
     scatterEffectMessages,
     extraDamages,
     actuallyDead,
-    scatterBroadcast: null,
-    // 稍后处理广播
     taskUpdates
   };
 }
 __name(handleScatterAttack, "handleScatterAttack");
-async function applyAttackResults(ctx, targetBoss, result) {
-  const { currentHP, isDefeated } = result;
-  if (isDefeated) {
-    await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, {
-      isActive: false,
-      HP: 0
-    });
-  } else {
-    await ctx.database.set("ggcevo_boss", { name: targetBoss.name }, {
-      HP: Math.max(currentHP, 0)
-    });
-  }
-}
-__name(applyAttackResults, "applyAttackResults");
 async function handleDeathTargets(ctx, deadTargets, killerName, killerHandle) {
   const bossBroadcast = [];
   const cleanerBroadcast = [];
@@ -4526,39 +4479,6 @@ async function handleDeathTargets(ctx, deadTargets, killerName, killerHandle) {
         "🏆 伤害排行榜奖励：",
         ...rewardMessages
       );
-    } else {
-      if (deadBoss.name === "机械感染虫") {
-        const [mainBoss] = await ctx.database.get("ggcevo_boss", {
-          groupId: deadBoss.groupId,
-          type: "主宰",
-          isActive: true
-        });
-        if (mainBoss && !mainBoss.skills.includes("孤立无援")) {
-          await ctx.database.set("ggcevo_boss", { name: mainBoss.name }, {
-            skills: [...mainBoss.skills, "孤立无援"]
-          });
-          bossBroadcast.push("💥 机械感染虫已阵亡，空间站感染虫进入【孤立无援】状态，受到的伤害+20%！");
-        }
-      } else {
-        const remainingMinions = await ctx.database.get("ggcevo_boss", {
-          groupId: deadBoss.groupId,
-          type: "子代",
-          isActive: true
-        });
-        if (remainingMinions.length === 0) {
-          const [mainBoss] = await ctx.database.get("ggcevo_boss", {
-            groupId: deadBoss.groupId,
-            type: "主宰",
-            isActive: true
-          });
-          if (mainBoss && !mainBoss.skills.includes("孤立无援")) {
-            await ctx.database.set("ggcevo_boss", { name: mainBoss.name }, {
-              skills: [...mainBoss.skills, "孤立无援"]
-            });
-            bossBroadcast.push(`💥 所有子代已阵亡，${mainBoss.name}进入【孤立无援】状态，受到的伤害+20%！`);
-          }
-        }
-      }
     }
   }
   return {
@@ -4669,13 +4589,8 @@ ${scatterResult.scatterEffectMessages.map((m) => `▸ ${m}`).join("\n")}`,
   return messages.filter((line) => line).join("\n");
 }
 __name(buildResultMessage, "buildResultMessage");
-async function handleBroadcasts(ctx, groupIds, scatterBroadcast, bossEventBroadcast, cleanerRewardBroadcast, isPrimaryAttack) {
+async function handleBroadcasts(ctx, groupIds, bossEventBroadcast, cleanerRewardBroadcast, isPrimaryAttack) {
   const broadcastMessages = [];
-  if (scatterBroadcast) {
-    const scatterMsg = Array.isArray(scatterBroadcast) ? scatterBroadcast.join("\n") : scatterBroadcast;
-    broadcastMessages.push(`✨ 散射攻击结果
-${scatterMsg}`);
-  }
   if (bossEventBroadcast) {
     const bossMsg = Array.isArray(bossEventBroadcast) ? bossEventBroadcast.join("\n") : bossEventBroadcast;
     broadcastMessages.push(bossMsg);
@@ -4717,6 +4632,91 @@ async function updateTaskProgress(ctx, handle, taskUpdates) {
   }
 }
 __name(updateTaskProgress, "updateTaskProgress");
+function getMaxHPByName2(bossName) {
+  for (const boss of bossPool) {
+    if (boss.main.name === bossName) {
+      return boss.main.maxHP;
+    }
+    for (const minion of boss.minions) {
+      if (minion.name === bossName) {
+        return minion.maxHP;
+      }
+    }
+  }
+  return void 0;
+}
+__name(getMaxHPByName2, "getMaxHPByName");
+function getMaxEnergyByName2(bossName) {
+  for (const boss of bossPool) {
+    if (boss.main.name === bossName) {
+      return boss.main.maxEnergy;
+    }
+    for (const minion of boss.minions) {
+      if (minion.name === bossName) {
+        return minion.maxEnergy;
+      }
+    }
+  }
+  return void 0;
+}
+__name(getMaxEnergyByName2, "getMaxEnergyByName");
+async function updateDatabaseWithStats(ctx, stats) {
+  const bossData = await ctx.database.get("ggcevo_boss", { name: stats.name });
+  const maxHP = getMaxHPByName2(stats.name);
+  const maxEnergy = getMaxEnergyByName2(stats.name);
+  if (!bossData || bossData.length === 0) {
+    return;
+  }
+  const boss = bossData[0];
+  const updateData = {};
+  if (stats.hpChange !== 0) {
+    const newHP = boss.HP + stats.hpChange;
+    updateData.HP = Math.max(0, Math.min(maxHP, newHP));
+  }
+  if (stats.energyChange !== 0) {
+    const newEnergy = boss.energy + stats.energyChange;
+    updateData.energy = Math.max(0, Math.min(maxEnergy, newEnergy));
+  }
+  if (stats.skillStacksChanged !== 0) {
+    updateData.skillStacks = Math.max(0, boss.skillStacks + stats.skillStacksChanged);
+  }
+  if (stats.statusLayersChanged !== 0) {
+    updateData.statusLayers = Math.max(0, boss.statusLayers + stats.statusLayersChanged);
+  }
+  if (stats.radiationLayersChange !== 0) {
+    updateData.radiationLayers = Math.max(0, boss.radiationLayers + stats.radiationLayersChange);
+  }
+  if (stats.coldLayersChange !== 0) {
+    updateData.coldLayers = Math.max(0, boss.coldLayers + stats.coldLayersChange);
+  }
+  if (stats.tagsAdded.length > 0 || stats.tagsRemoved.length > 0) {
+    updateData.tags = [
+      ...boss.tags.filter((tag) => !stats.tagsRemoved.includes(tag)),
+      ...stats.tagsAdded.filter((tag) => !boss.tags.includes(tag))
+    ];
+  }
+  if (stats.skillsAdded.length > 0 || stats.skillsRemoved.length > 0) {
+    updateData.skills = [
+      ...boss.skills.filter((skill) => !stats.skillsRemoved.includes(skill)),
+      ...stats.skillsAdded.filter((skill) => !boss.skills.includes(skill))
+    ];
+  }
+  if (stats.lastWeaponName) {
+    updateData.lastWeaponName = stats.lastWeaponName;
+  }
+  if (Object.keys(updateData).length > 0) {
+    await ctx.database.set("ggcevo_boss", { name: stats.name }, updateData);
+  }
+}
+__name(updateDatabaseWithStats, "updateDatabaseWithStats");
+async function saveAndClearStats(ctx) {
+  for (const name2 in battleStatsMap) {
+    const stats = battleStatsMap[name2];
+    await updateDatabaseWithStats(ctx, stats);
+  }
+  Object.keys(battleStatsMap).forEach((key) => delete battleStatsMap[key]);
+}
+__name(saveAndClearStats, "saveAndClearStats");
 
 // src/index.ts
 var name = "ggcevo-game";
@@ -4904,18 +4904,17 @@ function apply(ctx, config) {
   });
   ctx.model.extend("ggcevo_boss", {
     name: "string",
+    groupId: "unsigned",
     type: "string",
     HP: "unsigned",
-    tags: { type: "list", initial: [] },
-    skills: { type: "list", initial: [] },
-    // 明确数组元素类型
-    Skillcountpoints: "unsigned",
-    Vulnerability: "unsigned",
-    freezing: "unsigned",
     energy: "unsigned",
+    tags: "list",
+    skills: "list",
+    skillStacks: "unsigned",
+    statusLayers: "unsigned",
+    radiationLayers: "unsigned",
+    coldLayers: "unsigned",
     lastWeaponName: "string",
-    // 新增字段，记录伪装技能的信息
-    groupId: "unsigned",
     isActive: "boolean",
     respawnTime: "timestamp"
   }, {
@@ -4991,8 +4990,8 @@ function apply(ctx, config) {
     const totalBosses = await ctx.database.select("ggcevo_boss").execute((row) => import_koishi.$.count(row.name));
     const groupId = [...config.groupId];
     if (totalBosses === 0) {
-      await activateNextBossGroup(ctx);
-      await ctx.broadcast(groupId, `🔄 咕咕之战系统已初始化，首个主宰已登场！`);
+      const firstBoss = await activateNextBossGroup(ctx);
+      await ctx.broadcast(groupId, `🔄 咕咕之战系统已初始化，首个主宰【${firstBoss.name}】已登场！`);
       return;
     }
     const now = /* @__PURE__ */ new Date();
@@ -5002,10 +5001,14 @@ function apply(ctx, config) {
       isActive: false
     }).execute();
     for (const group of expiredGroups) {
+      const currentGroupId = group.groupId;
       await ctx.database.remove("ggcevo_boss_damage", {});
       await ctx.database.remove("ggcevo_boss", {});
-      await activateNextBossGroup(ctx, group.groupId);
-      await ctx.broadcast(groupId, `🔄 ${group.name}主宰组已刷新，快去挑战吧！`);
+      const newBossGroup = await activateNextBossGroup(ctx, currentGroupId);
+      await ctx.broadcast(
+        groupId,
+        `🔄 新的主宰【${newBossGroup.name}】组已刷新，快去挑战吧！`
+      );
     }
   }, 60 * 1e3);
   ctx.setInterval(async () => {
@@ -7183,7 +7186,6 @@ ${validTypes.join("、")}`;
   ctx.command("ggcevo/攻击 <bossName>").usage("请输入要攻击的异形名称(例如：攻击 异齿猛兽 或 攻击 寒冰王蛇)").action(async (argv, bossName) => {
     const session = argv.session;
     let bossEventBroadcast = null;
-    let scatterBroadcast = null;
     let cleanerRewardBroadcast = null;
     const [profile] = await ctx.database.get("sc2arcade_player", { userId: session.userId });
     if (!profile) return "🔒 需要先绑定游戏句柄。";
@@ -7229,16 +7231,11 @@ ${validTypes.join("、")}`;
       ctx,
       session,
       config2,
-      handle,
       equippedWeapon,
       targetBoss,
       activeBosses,
-      bossGroup,
-      weaponName,
-      weaponData,
-      maxHP
+      weaponName
     );
-    await applyAttackResults(ctx, targetBoss, primaryAttackResult);
     const allDeadTargets = [];
     if (primaryAttackResult.isDefeated) {
       allDeadTargets.push(targetBoss);
@@ -7251,20 +7248,17 @@ ${validTypes.join("、")}`;
         ctx,
         session,
         config2,
-        handle,
         equippedWeapon,
         targetBoss,
         weaponName,
-        weaponData,
-        activeBosses,
-        bossGroup
+        activeBosses
       );
       scatterResult.actuallyDead.forEach((name2) => {
         const deadBoss = activeBosses.find((b) => b.name === name2);
         if (deadBoss) allDeadTargets.push(deadBoss);
       });
     }
-    const totalDamage = primaryAttackResult.damage + (scatterResult ? scatterResult.extraDamages.reduce((sum, d) => sum + d.damage, 0) : 0);
+    const totalDamage = primaryAttackResult.initialDamage + (scatterResult ? scatterResult.extraDamages.reduce((sum, d) => sum + d.damage, 0) : 0);
     await updateBossDamageRecord(
       ctx,
       handle,
@@ -7289,7 +7283,7 @@ ${validTypes.join("、")}`;
     if (primaryAttackResult.freezing) {
       taskUpdates.push({ taskId: 2, count: 1 });
     }
-    if (primaryAttackResult.bileStacks >= 10) {
+    if (primaryAttackResult.bileStacks) {
       taskUpdates.push({ taskId: 3, count: 1 });
     }
     if (primaryAttackResult.pulseApplied) {
@@ -7323,7 +7317,6 @@ ${validTypes.join("、")}`;
     await handleBroadcasts(
       ctx,
       groupId,
-      scatterResult?.scatterBroadcast || null,
       bossEventBroadcast,
       cleanerRewardBroadcast,
       !isScatterAttack
@@ -7421,15 +7414,15 @@ ${validTypes.join("、")}`;
       `🔴 主宰：${mainBoss.name}`,
       `${mainBossHpBar} (${mainBoss.HP}/${bossGroup.main.maxHP})`
     ];
-    if (bossGroup.main.energy > 0) {
+    if (bossGroup.main.maxEnergy > 0) {
       result.push(`⚡ 能量：${mainBoss.energy}/1000`);
     }
     result.push(`🏷️ 标签：${mainBoss.tags?.join("、") || "无"}`);
-    if (mainBoss.Vulnerability > 0) {
-      result.push(`☢️ 辐射：${mainBoss.Vulnerability}层`);
+    if (mainBoss.radiationLayers > 0) {
+      result.push(`☢️ 辐射：${mainBoss.radiationLayers}层`);
     }
-    if (mainBoss.freezing > 0) {
-      result.push(`❄️ 寒冷：${mainBoss.freezing}层`);
+    if (mainBoss.coldLayers > 0) {
+      result.push(`❄️ 寒冷：${mainBoss.coldLayers}层`);
     }
     result.push(`✨ 被动：`);
     if (mainBoss.skills.length > 0) {
@@ -7439,7 +7432,7 @@ ${validTypes.join("、")}`;
     }
     const countingSkill = mainBoss.skills?.find((s) => ["冷适应", "岗哨机枪", "吸血唾液", "灼烧粘液", "光影之刃"].includes(s));
     if (countingSkill) {
-      result.push(`📈 ${countingSkill}：${mainBoss.Skillcountpoints}层`);
+      result.push(`📈 ${countingSkill}：${mainBoss.skillStacks}层`);
     }
     if (mainBoss.lastWeaponName) {
       result.push(`🎭 记录武器：${mainBoss.lastWeaponName}`);
@@ -7454,15 +7447,15 @@ ${validTypes.join("、")}`;
           `❤️ ${minion.name}`,
           `${minionHpBar} (${minion.HP}/${minionConfig?.maxHP || "未知"})`
         ];
-        if (minionConfig && minionConfig.energy > 0) {
+        if (minionConfig && minionConfig.maxEnergy > 0) {
           minionInfo.push(`⚡ 能量：${minion.energy}/1000`);
         }
         minionInfo.push(`🏷️ 标签：${minion.tags?.join("、") || "无"}`);
-        if (minion.Vulnerability > 0) {
-          minionInfo.push(`☢️ 辐射：${minion.Vulnerability}层`);
+        if (minion.radiationLayers > 0) {
+          minionInfo.push(`☢️ 辐射：${minion.radiationLayers}层`);
         }
-        if (minion.freezing > 0) {
-          minionInfo.push(`❄️ 寒冷：${minion.freezing}层`);
+        if (minion.coldLayers > 0) {
+          minionInfo.push(`❄️ 寒冷：${minion.coldLayers}层`);
         }
         minionInfo.push(`✨ 被动：`);
         if (minion.skills.length > 0) {
@@ -7472,7 +7465,7 @@ ${validTypes.join("、")}`;
         }
         const minionCountingSkill = minion.skills?.find((s) => ["冷适应", "岗哨机枪", "吸血唾液", "灼烧粘液", "光影之刃"].includes(s));
         if (minionCountingSkill) {
-          minionInfo.push(`📈 ${minionCountingSkill}：${minion.Skillcountpoints}层`);
+          minionInfo.push(`📈 ${minionCountingSkill}：${minion.skillStacks}层`);
         }
         if (minion.lastWeaponName) {
           minionInfo.push(`🎭 记录武器：${minion.lastWeaponName}`);
@@ -7485,19 +7478,19 @@ ${validTypes.join("、")}`;
   });
   ctx.command("ggcevo/初始化异形 <groupid:number>", "初始化指定主宰组", { authority: 3 }).alias("初始化yx").action(async (_, groupid) => {
     if (!groupid) groupid = 1;
-    const bossConfig = bossPool.find((g) => g.main.id === groupid);
+    const bossConfig = bossPool.find((g) => g.id === groupid);
     if (!bossConfig) {
       return `未找到groupid为${groupid}的异形配置`;
     }
     await ctx.database.remove("ggcevo_boss_damage", {});
     await ctx.database.remove("ggcevo_boss", {});
-    const mainBoss = await ctx.database.create("ggcevo_boss", {
+    await ctx.database.create("ggcevo_boss", {
       name: bossConfig.main.name,
       type: "主宰",
       HP: bossConfig.main.maxHP,
       tags: bossConfig.main.tags,
       skills: [...bossConfig.main.passive],
-      energy: bossConfig.main.energy,
+      energy: bossConfig.main.maxEnergy,
       groupId: groupid,
       isActive: true,
       respawnTime: /* @__PURE__ */ new Date()
@@ -7509,13 +7502,13 @@ ${validTypes.join("、")}`;
         HP: minion.maxHP,
         tags: minion.tags,
         skills: [...minion.passive],
-        energy: minion.energy,
+        energy: minion.maxEnergy,
         groupId: groupid,
         isActive: true,
         respawnTime: /* @__PURE__ */ new Date()
       });
     }
-    return `✅ 异形初始化成功！当前主宰：${bossConfig.main.name}(HP:${bossConfig.main.maxHP})`;
+    return `✅ 异形初始化成功！当前主宰：${bossConfig.main.name}`;
   });
   ctx.command("ggcevo/祈愿").action(async (argv) => {
     const session = argv.session;
@@ -8443,7 +8436,7 @@ ${Spacestationtechnology.map((t) => t.techname).join("、")}`;
         handle,
         taskId: taskConfig.id
       });
-      if (!taskData) return `⚠️ 任务进度不足！无法完成"${taskName}"任务`;
+      if (!taskData) return `⚠️ 任务进度不足！当前进度：0/${taskConfig.target}`;
       if (taskData.progress < taskConfig.target) {
         return `⚠️ 任务进度不足！当前进度：${taskData.progress}/${taskConfig.target}`;
       }
@@ -8475,12 +8468,12 @@ ${Spacestationtechnology.map((t) => t.techname).join("、")}`;
         totalRewards: newTotalRewards
       }], ["handle"]);
       const response = [
-        `🎉 成功完成【${taskName}】任务！`
+        `🎉 成功完成 ${completableTimes} 次【${taskName}】任务！`
       ];
       if (totalBonus > 0) {
-        response.push(`💰 获得总奖励：${totalReward}金币 (基础值: ${baseTotal}金币)`);
+        response.push(`💰 获得奖励：${totalReward}金币 (基础值: ${baseTotal}金币)`);
       } else {
-        response.push(`💰 获得总奖励：${totalReward}金币`);
+        response.push(`💰 获得奖励：${totalReward}金币`);
       }
       if (totalBonus > 0) {
         response.push(`⚡ 加成效果：`);
@@ -8495,12 +8488,6 @@ ${Spacestationtechnology.map((t) => t.techname).join("、")}`;
         `📊 累计完成次数: ${newCompletions}次`,
         `⚙️ 剩余进度点数: ${remainingProgress}/${taskConfig.target}`
       );
-      if (remainingProgress > 0) {
-        response.push(`💡 剩余进度可完成 ${Math.floor(remainingProgress / taskConfig.target)} 次`);
-      }
-      if (completableTimes > 1) {
-        response.push(`💡 成功完成${completableTimes}次任务，已发放全部奖励`);
-      }
       return response.join("\n");
     } catch (error) {
       console.error("完成任务命令时发生错误:", error);