koishi-plugin-ggcevo-game 1.4.37 → 1.4.39

package/lib/index.js

@@ -919,8 +919,8 @@ var Spacestationtechnology = [
       {
         level: 2,
         cost: 1e3,
-        description: "重启高级武器改装站，武器改装通用模块享有10%的折扣",
-        careerBonus: "武器改装通用模块享有20%的折扣; 武器改装专属模块享有10%的折扣"
+        description: "重启高级武器改装站，武器改装通用模块享有5%的折扣; 武器改装专属模块享有5%的折扣",
+        careerBonus: "武器改装通用模块享有10%的折扣; 武器改装专属模块享有10%的折扣"
       }
     ]
   },
@@ -1274,211 +1274,211 @@ var bossPool = [
 var passiveConfig = {
   "弱化形态": {
     type: "伤害增减（负面）",
-    description: "子代防御脆弱，所受伤害提升10%"
+    description: "子代防御脆弱，受到的伤害提高10%"
   },
   "异形甲壳": {
     type: "伤害增减（正面）",
-    description: "强化生物甲壳提供防护，所受伤害降低20%"
+    description: "受到的伤害降低20%"
   },
   "冰霜回复": {
     type: "生存强化（生命回复）",
-    description: "生命值降至30%以下时触发，立即回复自身40%最大生命值，并为其他存活异形回复10%最大生命值（触发后效果移除）"
+    description: "生命值≤30%时，立即回复自身40%最大生命值，并为所有其他存活异形回复10%最大生命值（生效后移除）"
   },
   "冰霜进化": {
     type: "状态免疫（寒冷伤害免疫）",
-    description: "免疫寒冷类伤害，受到寒冷伤害时额外回复生命值"
+    description: "免疫寒冷伤害，受到寒冷攻击时回复等量生命值"
   },
   "冰霜环绕": {
     type: "生存强化（生命回复+群体增益）",
-    description: "生命值降至30%以下时触发，立即回复自身45%最大生命值，并使所有存活异形获得「寒霜地狱」技能（自身效果触发后移除）"
+    description: "生命值≤30%时，立即回复自身45%最大生命值，并使所有存活异形获得「寒霜地狱」技能（生效后移除）"
   },
   "寒霜地狱": {
     type: "伤害增减（正面）",
-    description: "暴风雪笼罩战场，所受伤害降低30%"
+    description: "受到的伤害降低30%"
   },
   "应激甲壳I": {
     type: "伤害增减（正面）",
-    description: "基础应激甲壳生效，所受伤害降低20%"
+    description: "受到的伤害降低20%"
   },
   "应激甲壳II": {
     type: "伤害增减（正面）",
-    description: "进阶应激甲壳生效，所受伤害降低25%"
+    description: "受到的伤害降低25%"
   },
   "求生本能I": {
     type: "生存强化（生命回复）",
-    description: "濒死状态下，快速回复30%最大生命值（触发后效果移除）"
+    description: "濒死时立即回复自身30%最大生命值（生效后移除）"
   },
   "求生本能II": {
     type: "生存强化（生命回复）",
-    description: "濒死状态下，快速回复50%最大生命值（触发后效果移除）"
+    description: "濒死时立即回复自身50%最大生命值（生效后移除）"
   },
   "冷适应": {
     type: "状态免疫（寒冷伤害免疫）",
-    description: "累计承受10次寒冷伤害后，获得「惧热」标签并获得寒冷伤害免疫"
+    description: "累计承受10次寒冷伤害后，获得「惧热」标签并永久免疫寒冷伤害"
   },
   "感染空间站": {
     type: "伤害增减（正面）",
-    description: "若「空间站哨枪塔」存活，自身所受伤害降低50%"
+    description: "当空间站哨枪塔存活时，自身受到的伤害降低50%"
   },
   "病毒云": {
     type: "伤害增减（正面）",
-    description: "释放病毒云雾形成保护，所受伤害降低10%"
+    description: "受到的伤害降低10%"
   },
   "霉菌滋生": {
     type: "生存强化（生命回复）",
-    description: "受到攻击后，若「空间站哨枪塔」存活，为其回复1%最大生命值"
+    description: "受击后，若空间站哨枪塔存活，为其回复1%最大生命值"
   },
   "岗哨机枪": {
     type: "生存强化（生命回复）",
-    description: "每累计承受10次攻击后，为所有其他存活异形回复其10%最大生命值"
+    description: "每累计承受10次攻击，为所有其他存活异形回复10%最大生命值"
   },
   "结构装甲": {
     type: "伤害增减（正面）",
-    description: "装备结构装甲，常规伤害降低20%；若伤害来源为热能武器，伤害降低提升至40%"
+    description: "受实弹/能量武器伤害降低20%，受热能武器伤害降低40%"
   },
   "吸血唾液": {
     type: "伤害增减（正面）",
-    description: "受到攻击时叠加「吸血唾液」层数，每层提供5%减伤（最多叠加20层）"
+    description: "受击获得1层「吸血唾液」(上限20层)，每层使受到的伤害降低5%"
   },
   "进食": {
     type: "生存强化（生命回复）",
-    description: "当「吸血唾液」层数达到20层时，下一次受击消耗所有层数并回复20%最大生命值"
+    description: "「吸血唾液」≥20层时，下次受击消耗所有层数并回复自身20%最大生命值"
   },
   "嗜血狂暴": {
     type: "伤害增减（正面）",
-    description: "生命值低于50%时触发狂暴状态，每次受击额外叠加1层「吸血唾液」，同时所受伤害降低20%"
+    description: "生命值≤50%时，受击额外获得1层「吸血唾液」且受到的伤害降低20%"
   },
   "吐血": {
     type: "伤害增减（负面）",
-    description: "无「吸血唾液」层数时，所受伤害提升20%"
+    description: "无「吸血唾液」层数时，受到的伤害提高20%"
   },
   "超导体": {
     type: "状态转换（护盾→重甲）",
-    description: "生命值降至10%以下时，「护盾」标签转换为「重甲」标签"
+    description: "生命值≤10%时，护盾标签永久转换为重甲标签"
   },
   "能量虹吸": {
     type: "伤害增减（正面）",
-    description: "生命值≥70%时，所受伤害降低40%；生命值≥30%时，伤害降低20%"
+    description: "生命值≥70%时伤害降低40%，30%-70%时伤害降低20%"
   },
   "能源虹吸": {
     type: "伤害增减（正面）",
-    description: "能量值≥80%时，所受伤害降低50%；能量值≥50%时，伤害降低30%"
+    description: "能量值≥80%时伤害降低50%，50%-80%时伤害降低30%"
   },
   "电能立场": {
     type: "状态免疫（伤害免疫）",
-    description: "能量值≥30%时，每次受击有55%概率免疫该次伤害（无法免疫寒冷伤害）；每存在1层「寒冷」状态，免疫概率降低5%（至多降低50%）"
+    description: "能量值≥30%时，55%概率免疫非热能伤害（每层寒冷降低5%触发概率）"
   },
   "电能冲击波": {
     type: "生存强化（能量回复）",
-    description: "每次受击时，回复100点「能量」"
+    description: "受击后回复100点能量"
   },
   "脉冲": {
     type: "生存强化（生命回复）",
-    description: "能量值≥30%时，每次受击有60%概率为所有存活异形回复100点生命值；每存在1层「寒冷」状态，概率降低5%（至多降低50%）"
+    description: "能量值≥30%时，60%概率为所有存活异形回复100点生命（每层寒冷降低5%触发概率）"
   },
   "能量黑洞": {
     type: "伤害增减（正面）",
-    description: "存在「能量黑洞」时，所受伤害降低20%"
+    description: "存在能量黑洞时，受到的伤害降低20%"
   },
   "火焰异形": {
     type: "状态免疫（火焰伤害免疫）",
-    description: "免疫火焰类伤害，受到火焰伤害时额外回复生命值"
+    description: "免疫火焰伤害，受到火焰攻击时回复等量生命值"
   },
   "庞兽狂暴": {
     type: "伤害增减（正面）",
-    description: "生命值低于50%时触发狂暴状态，所受伤害降低50%"
+    description: "生命值≤50%时，受到的伤害降低50%"
   },
   "灼烧粘液": {
     type: "生存强化（生命回复）",
-    description: "受到伤害时叠加「灼烧粘液」层数；若存在「灼烧粘液」层数时受到火焰攻击，立即清空层数并回复（层数×10）点生命值"
+    description: "受击获得1层「灼烧粘液」；受火焰攻击时消耗所有层数并回复（层数×10）点生命"
   },
   "腐蚀胆汁": {
     type: "生存强化（生命回复）",
-    description: "「灼烧粘液」层数达到10层时，下一次受击为所有存活异形回复1000点生命值并清空层数"
+    description: "「灼烧粘液」≥10层时，下次受击消耗所有层数并为所有存活异形回复1000点生命"
   },
   "火焰吐息": {
     type: "生存强化（生命回复）",
-    description: "「灼烧粘液」层数达到20层时，下一次攻击为所有存活异形回复20%最大生命值并清空层数"
+    description: "「灼烧粘液」≥20层时，下次攻击消耗所有层数并为所有存活异形回复20%最大生命值"
   },
   "太阳耀斑": {
     type: "状态移除+状态免疫（寒冷伤害免疫）",
-    description: "所有子代阵亡后，移除「惧寒」标签及「孤立无援」并获得寒冷伤害免疫"
+    description: "所有子代阵亡后，移除惧寒标签和孤立无援状态，并永久免疫寒冷伤害"
   },
   "燃烧潜地": {
     type: "生存强化（生命回复）",
-    description: "生命值降至10%以下时触发，立即回复50%最大生命值（触发后效果移除）"
+    description: "生命值≤10%时立即回复50%最大生命值（生效后移除）"
   },
   "炼狱爆弹": {
     type: "伤害增减（正面）",
-    description: "每存在1层「灼烧粘液」，所受伤害降低5%；若存在存活子代，伤害降低效果额外提升5%（即每层「灼烧粘液」总降低10%）"
+    description: "每层「灼烧粘液」使受到的伤害降低5%，存活子代存在时每层额外降低5%"
   },
   "猎手异形": {
     type: "伤害增减（条件性）+状态免疫（火焰/寒冷伤害免疫）",
-    description: "存在其他存活异形时，所受伤害降低20%；无其他存活异形时，所受伤害提升20%；免疫火焰及寒冷伤害"
+    description: "存在其他存活异形时伤害降低20%，无其他存活异形时伤害提高20%；免疫火焰及寒冷伤害"
   },
   "狂暴": {
     type: "伤害增减（正面）",
-    description: "生命值低于50%时触发狂暴状态，所受伤害降低50%"
+    description: "生命值≤50%时，受到的伤害降低50%"
   },
   "伪装": {
     type: "伤害增减（正面）",
-    description: "受击时记录伤害来源的武器名称（仅保留最新），下次受到同名称武器伤害时伤害降低80%"
+    description: "受击记录伤害来源武器名称，下次被同名武器攻击时伤害降低80%"
   },
   "致命一击": {
     type: "状态免疫（伤害免疫）",
-    description: "受击时有5%概率免疫该次伤害"
+    description: "受击时5%概率免疫该次伤害"
   },
   "星界之风": {
     type: "生存强化（生命回复）",
-    description: "受击时有5%概率为所有存活异形回复200点生命值"
+    description: "受击时5%概率为所有存活异形回复200点生命"
   },
   "心灵狂热": {
     type: "伤害增减（正面）",
-    description: "生命值低于50%时进入心灵狂热状态，所受伤害降低20%，同时「星界之风」触发概率翻倍"
+    description: "生命值<50%时伤害降低20%且「星界之风」触发概率翻倍"
   },
   "宇宙能量": {
     type: "生存强化（能量/生命回复）",
-    description: "受击时回复等同于本次伤害值的「能量」；若「能量」已满，则将溢出部分转换为自身生命值"
+    description: "受击回复等量能量值，能量溢出时转换为生命回复"
   },
   "复苏": {
     type: "生存强化（生命/能量回复）",
-    description: "承受致命伤害时免疫死亡，立即回复50%最大生命值及100%「能量」，并获得「灵能构造炉」技能（触发后效果移除）"
+    description: "免疫致命伤害，回复50%最大生命与100%能量值，并获得「灵能构造炉」技能（生效后移除）"
   },
   "光影之刃": {
     type: "状态叠加（层数叠加）",
-    description: "受击后叠加「光影之刃」层数(至多50层)"
+    description: "受击获得1层「光影之刃」(上限50层)"
   },
   "远古预兆": {
     type: "状态免疫（能量伤害免疫）",
-    description: "受击时有1%概率免疫能量武器伤害并回复100点「能量」"
+    description: "受击时1%概率免疫非热能伤害并回复100点能量"
   },
   "闪电冲锋": {
     type: "状态增强（触发概率提升）",
-    description: "每存在1层「光影之刃」，「远古预兆」「灵能构造炉」触发概率各提升0.5%"
+    description: "每层「光影之刃」使「远古预兆」和「灵能构造炉」触发概率提升0.5%"
   },
   "超视距穿梭": {
     type: "伤害增减（条件性）",
-    description: "能量值≥30%时，每层「光影之刃」降低5%所受伤害；能量值≥60%时，每层降低10%；能量值≤10%时，每层提升5%所受伤害"
+    description: "能量≥60%时每层「光影之刃」使伤害降低10%，30%-60%时每层降低5%，能量≤10%时每层提高5%"
   },
   "灵能构造炉": {
     type: "状态获得（技能获得）",
-    description: "受击后有5%概率随机获得以下技能之一：天启超载护盾、塌缩脉冲、地毯式轰炸、轰炸引导"
+    description: "受击时5%概率随机获得以下技能之一：天启超载护盾/塌缩脉冲/地毯式轰炸/轰炸引导"
   },
   "天启超载护盾": {
     type: "生存强化（生命回复）",
-    description: "受击后有5%概率为所有存活异形回复（「光影之刃」层数×10）点生命值"
+    description: "受击时10%概率为所有存活异形回复（「光影之刃」层数×10）点生命"
   },
   "塌缩脉冲": {
     type: "状态叠加（层数叠加）",
-    description: "受击后额外叠加1层「光影之刃」"
+    description: "受击后额外获得1层「光影之刃」"
   },
   "地毯式轰炸": {
     type: "状态移除+伤害增减（正面）",
-    description: "触发时移除「孤立无援」，并使自身所受伤害降低100%"
+    description: "移除孤立无援状态，受到的伤害降低100%"
   },
   "轰炸引导": {
     type: "生存强化（能量回复）",
-    description: "受击后有5%概率回复（「光影之刃」层数×50）点「能量」"
+    description: "受击时10%概率回复（「光影之刃」层数×50）点能量"
   }
 };
 
@@ -2448,7 +2448,7 @@ var BattleEffectProcessor = {
   handleWeakForm: /* @__PURE__ */ __name(function(targetBoss) {
     if (targetBoss.skills.includes("弱化形态")) {
       const newBuffMultiplier = 0.1;
-      const messages = [`📚 【弱化形态】生效：子代防御脆弱，所受伤害提升10%`];
+      const messages = [`📚 【弱化形态】生效：子代防御脆弱，受到的伤害+10%`];
       return {
         buffMultiplier: newBuffMultiplier,
         messages
@@ -2460,7 +2460,7 @@ var BattleEffectProcessor = {
   handleAlienShell: /* @__PURE__ */ __name(function(targetBoss) {
     if (targetBoss.skills.includes("异形甲壳")) {
       const newNerfMultiplier = 0.2;
-      const messages = [`🛡️ 【异形甲壳】生效：强化生物甲壳提供防护，所受伤害降低20%`];
+      const messages = [`🛡️ 【异形甲壳】生效：受到的伤害-20%`];
       return {
         nerfMultiplier: newNerfMultiplier,
         messages
@@ -2469,13 +2469,16 @@ var BattleEffectProcessor = {
     return null;
   }, "handleAlienShell"),
   // 孤立无援处理（活跃Boss中仅自己时增伤20%）
-  handleIsolated: /* @__PURE__ */ __name(function(targetBoss, activeBosses) {
+  handleIsolated: /* @__PURE__ */ __name(function(targetBoss, activeBosses, tempMark) {
+    if (tempMark) {
+      return null;
+    }
     const isIsolated = activeBosses.length === 1 && // 活跃Boss仅1个
     activeBosses[0].name === targetBoss.name;
     if (isIsolated) {
       const newBuffMultiplier = 0.2;
       const messages = [
-        `🌌 【孤立无援】生效：无存活子代时，所受伤害提升20%`
+        `📚 【孤立无援】生效：无存活子代时，受到的伤害+20%`
       ];
       return {
         buffMultiplier: newBuffMultiplier,
@@ -2502,7 +2505,7 @@ var BattleEffectProcessor = {
       skillsRemoved: ["冰霜回复"]
       // 移除技能
     };
-    messages.push(`❄️ 【冰霜回复】生效：自身回复${selfHealAmount}点生命值`);
+    messages.push(`❄️ 【冰霜回复】触发：生命值≤30%，自身回复${selfHealAmount}点生命值`);
     const otherSurvivingBosses = activeBosses.filter(
       (boss) => boss.name !== targetBoss.name && boss.isActive
     );
@@ -2516,7 +2519,7 @@ var BattleEffectProcessor = {
       });
       messages.push(`❄️ 「${otherName}」回复${otherHealAmount}点生命值`);
     });
-    messages.push(`❄️ 【冰霜回复】触发后技能移除`);
+    messages.push(`❄️ 【冰霜回复】技能移除`);
     return {
       messages,
       targetUpdates: {
@@ -2547,8 +2550,8 @@ var BattleEffectProcessor = {
       skillsAdded: ["寒霜地狱"]
       // 新增【寒霜地狱】技能（自身）
     };
-    messages.push(`❄️ 【冰霜环绕】生效：自身回复${selfHealAmount}点生命值`);
-    messages.push(`❄️ 「${targetBoss.name}」获得【寒霜地狱】技能`);
+    messages.push(`❄️ 【冰霜环绕】触发：生命值≤30%，自身回复${selfHealAmount}点生命值`);
+    messages.push(`❄️ 「${targetBoss.name}」获得「寒霜地狱」技能`);
     const survivingMinions = activeBosses.filter(
       (boss) => boss.name !== targetBoss.name && boss.isActive
     );
@@ -2563,10 +2566,10 @@ var BattleEffectProcessor = {
           name: minionName,
           updates: minionUpdates
         });
-        messages.push(`❄️ 「${minionName}」获得【寒霜地狱】技能`);
+        messages.push(`❄️ 「${minionName}」获得「寒霜地狱」技能`);
       });
     }
-    messages.push(`❄️ 【冰霜环绕】触发后技能移除`);
+    messages.push(`❄️ 【冰霜环绕】技能移除`);
     return {
       messages,
       targetUpdates: {
@@ -2596,8 +2599,7 @@ var BattleEffectProcessor = {
         // 生命值变化量
       }
     };
-    messages.push(`❄️ 【冰霜进化】生效：「${targetBoss.name}」免疫寒冷伤害`);
-    messages.push(`❄️ 恢复${healAmount}点生命值`);
+    messages.push(`❄️ 【冰霜进化】生效：免疫寒冷伤害并回复${healAmount}点生命值`);
     return {
       isImmune,
       messages,
@@ -2608,7 +2610,7 @@ var BattleEffectProcessor = {
   handleFrostHell: /* @__PURE__ */ __name(function(targetBoss) {
     if (targetBoss.skills.includes("寒霜地狱")) {
       const newNerfMultiplier = 0.3;
-      const messages = [`❄️ 【寒霜地狱】生效：暴风雪笼罩战场，所受伤害降低30%`];
+      const messages = [`❄️ 【寒霜地狱】生效：受到的伤害-30%`];
       return {
         nerfMultiplier: newNerfMultiplier,
         messages
@@ -2620,7 +2622,7 @@ var BattleEffectProcessor = {
   handleStressShellI: /* @__PURE__ */ __name(function(targetBoss) {
     if (targetBoss.skills.includes("应激甲壳I")) {
       const newNerfMultiplier = 0.2;
-      const messages = [`🛡️ 【应激甲壳I】生效：基础应激甲壳生效，所受伤害降低20%`];
+      const messages = [`🛡️ 【应激甲壳I】生效：受到的伤害-20%`];
       return {
         nerfMultiplier: newNerfMultiplier,
         messages
@@ -2632,7 +2634,7 @@ var BattleEffectProcessor = {
   handleStressShellII: /* @__PURE__ */ __name(function(targetBoss) {
     if (targetBoss.skills.includes("应激甲壳II")) {
       const newNerfMultiplier = 0.25;
-      const messages = [`🛡️ 【应激甲壳II】生效：进阶应激甲壳生效，所受伤害降低25%`];
+      const messages = [`🛡️ 【应激甲壳II】生效：受到的伤害-25%`];
       return {
         nerfMultiplier: newNerfMultiplier,
         messages
@@ -2655,8 +2657,8 @@ var BattleEffectProcessor = {
       hpChange: selfHealAmount,
       skillsRemoved: ["求生本能I"]
     };
-    messages.push(`❤️ 【求生本能I】生效：生命值归零时回复${selfHealAmount}点生命值`);
-    messages.push(`❤️ 「${targetBoss.name}」的【求生本能I】技能已移除`);
+    messages.push(`❤️ 【求生本能I】触发：濒死时，回复${selfHealAmount}点生命值`);
+    messages.push(`❤️ 【求生本能I】技能移除`);
     return {
       messages,
       targetUpdates: {
@@ -2682,8 +2684,8 @@ var BattleEffectProcessor = {
       skillsRemoved: ["求生本能II"]
       // 移除的技能
     };
-    messages.push(`❤️ 【求生本能II】生效：生命值归零时回复${selfHealAmount}点生命值`);
-    messages.push(`❤️ 「${targetBoss.name}」的【求生本能II】技能已移除`);
+    messages.push(`❤️ 【求生本能II】触发：濒死时，回复${selfHealAmount}点生命值`);
+    messages.push(`❤️ 【求生本能II】技能移除`);
     return {
       messages,
       targetUpdates: {
@@ -2720,11 +2722,10 @@ var BattleEffectProcessor = {
           // 层数+1
         }
       };
-      messages.push(`❄️ 【冷适应】叠加状态：当前累计${newLayers}/10次寒冷伤害`);
+      messages.push(`❄️ 【冷适应】叠层：当前${newLayers}/10次寒冷伤害`);
       if (newLayers >= 10) {
         targetUpdates.updates.tagsAdded = ["惧热"];
-        messages.push(`🧊 【冷适应】触发：累计承受10次寒冷伤害，获得「惧热」标签`);
-        messages.push(`🧊 【冷适应】获得永久免疫寒冷伤害效果`);
+        messages.push(`🧊 【冷适应】生效：获得「惧热」标签并免疫寒冷伤害`);
       }
     }
     return {
@@ -2746,7 +2747,7 @@ var BattleEffectProcessor = {
       return null;
     }
     const newNerfMultiplier = 0.5;
-    messages.push(`🛸 【感染空间站】生效：因「空间站哨枪塔」存活，自身所受伤害降低50%`);
+    messages.push(`🛸 【感染空间站】生效：「空间站哨枪塔」存活，受到的伤害-50%`);
     return {
       nerfMultiplier: newNerfMultiplier,
       // 返回调整后的减伤系数
@@ -2760,7 +2761,7 @@ var BattleEffectProcessor = {
       return null;
     }
     const newNerfMultiplier = 0.1;
-    messages.push(`☁️ 【病毒云】生效：释放病毒云雾形成保护，所受伤害降低10%`);
+    messages.push(`☁️ 【病毒云】生效：受到的伤害-10%`);
     return {
       nerfMultiplier: newNerfMultiplier,
       // 返回调整后的减伤系数
@@ -2787,7 +2788,7 @@ var BattleEffectProcessor = {
         hpChange: healAmount
       }
     };
-    messages.push(`🍄 【霉菌滋生】生效：为空间站哨枪塔回复${healAmount}点生命值`);
+    messages.push(`🍄 【霉菌滋生】生效：为「空间站哨枪塔」回复${healAmount}点生命值`);
     return {
       messages,
       spaceStationUpdates
@@ -2811,7 +2812,7 @@ var BattleEffectProcessor = {
         }
       };
       const newStacks = currentStacks + 1;
-      messages.push(`🔫 【岗哨机枪】充能：当前累计${newStacks}/10次攻击`);
+      messages.push(`🔫 【岗哨机枪】充能：当前${newStacks}/10次攻击`);
       return {
         messages,
         targetUpdates,
@@ -2825,7 +2826,6 @@ var BattleEffectProcessor = {
         // 重置层数
       }
     };
-    messages.push(`🔫 【岗哨机枪】生效：累计承受10次攻击，为所有其他存活异形回复生命值`);
     const otherSurvivingBosses = activeBosses.filter(
       (boss) => boss.name !== targetBoss.name && boss.isActive
     );
@@ -2857,7 +2857,7 @@ var BattleEffectProcessor = {
     const weaponType = weaponData.type;
     const isHeatWeapon = weaponType === "热能武器";
     const nerfMultiplier = isHeatWeapon ? 0.4 : 0.2;
-    messages.push(`🛡️ 【结构装甲】生效：${isHeatWeapon ? "热能武器" : "常规武器"}伤害降低${nerfMultiplier * 100}%`);
+    messages.push(`🛡️ 【结构装甲】生效：受到${weaponType}的伤害-${nerfMultiplier * 100}%`);
     return {
       nerfMultiplier,
       messages
@@ -2882,8 +2882,8 @@ var BattleEffectProcessor = {
         }
       };
     }
-    const stackMessage = currentStacks < 20 ? `当前${currentStacks}层，获得${(addedReduction * 100).toFixed(0)}%减伤，同时层数+1` : `已达到最大20层，获得${(addedReduction * 100).toFixed(0)}%减伤`;
-    messages.push(`🩸 【吸血唾液】${stackMessage}`);
+    messages.push(`🩸 【吸血唾液】生效：当前${currentStacks}层，受到的伤害-${(addedReduction * 100).toFixed(0)}%`);
+    messages.push(`🩸 【吸血唾液】叠层：「吸血唾液」层数+1`);
     return {
       nerfMultiplier: addedReduction,
       messages,
@@ -2911,7 +2911,7 @@ var BattleEffectProcessor = {
         // 生命值回复
       }
     };
-    messages.push(`🍽️ 【进食】生效：消耗20层吸血唾液，回复${healAmount}点生命值`);
+    messages.push(`🍽️ 【进食】触发：消耗20层「吸血唾液」，回复${healAmount}点生命值`);
     return {
       messages,
       targetUpdates
@@ -2940,8 +2940,7 @@ var BattleEffectProcessor = {
         };
       }
       nerfMultiplier = 0.2;
-      const stackMessage = currentStacks < 20 ? `额外叠加1层吸血唾液（当前${currentStacks + 1}/20层）` : `已达到最大20层吸血唾液`;
-      messages.push(`🔥 【嗜血狂暴】生效：HP≤50%，${stackMessage}，并且获得20%额外减伤`);
+      messages.push(`🔥 【嗜血狂暴】生效：生命值≤50%，每次受击+1层「吸血唾液」且受到的伤害-20%`);
     }
     return {
       nerfMultiplier,
@@ -2959,7 +2958,7 @@ var BattleEffectProcessor = {
     const isTriggered = currentVampireStacks === 0;
     const buffMultiplier = isTriggered ? 0.2 : 0;
     if (isTriggered) {
-      messages.push(`🩸 【吐血】生效：无「吸血唾液」层数，所受伤害提升20%`);
+      messages.push(`🩸 【吐血】生效：无「吸血唾液」层数，受到的伤害+20%`);
     }
     return {
       buffMultiplier,
@@ -2988,7 +2987,7 @@ var BattleEffectProcessor = {
         // 添加重甲标签
       }
     };
-    messages.push(`🛡️ 【超导体】生效：生命值≤10%，「护盾」标签转换为「重甲」标签`);
+    messages.push(`🛡️ 【超导体】触发：生命值≤10%，「护盾」标签转换为「重甲」标签`);
     return {
       messages,
       targetUpdates
@@ -3003,10 +3002,10 @@ var BattleEffectProcessor = {
     let nerfMultiplier = 0;
     if (hpPercent >= 0.7) {
       nerfMultiplier = 0.4;
-      messages.push(`⚡ 【能量虹吸】生效：生命值≥70%，所受伤害降低40%`);
+      messages.push(`⚡ 【能量虹吸】生效：生命值≥70%，受到的伤害-40%`);
     } else if (hpPercent >= 0.3) {
       nerfMultiplier = 0.2;
-      messages.push(`⚡ 【能量虹吸】生效：生命值≥30%，所受伤害降低20%`);
+      messages.push(`⚡ 【能量虹吸】生效：生命值≥30%，受到的伤害-20%`);
     }
     return { nerfMultiplier, messages };
   }, "handleEnergySiphon"),
@@ -3020,18 +3019,20 @@ var BattleEffectProcessor = {
     let nerfMultiplier = 0;
     if (energyPercent >= 0.8) {
       nerfMultiplier = 0.5;
-      messages.push(`⚡ 【能源虹吸】生效：能量≥80%，所受伤害降低50%`);
+      messages.push(`⚡ 【能源虹吸】生效：能量值≥80%，受到的伤害-50%`);
     } else if (energyPercent >= 0.5) {
       nerfMultiplier = 0.3;
-      messages.push(`⚡ 【能源虹吸】生效：能量≥50%，所受伤害降低30%`);
+      messages.push(`⚡ 【能源虹吸】生效：能量值≥50%，受到的伤害-30%`);
     }
     return { nerfMultiplier, messages };
   }, "handleEnergyAbsorption"),
-  // 电能立场（能量相关免疫）
-  handleElectricField: /* @__PURE__ */ __name(function(targetBoss) {
+  handleElectricField: /* @__PURE__ */ __name(function(targetBoss, weaponData) {
     const messages = [];
     let isImmune = false;
     if (!targetBoss.skills.includes("电能立场")) return null;
+    if (weaponData.type === "热能武器") {
+      return null;
+    }
     const currentEnergy = targetBoss.energy;
     const maxEnergy = getMaxEnergyByName(targetBoss.name);
     const energyPercent = currentEnergy / maxEnergy;
@@ -3043,8 +3044,10 @@ var BattleEffectProcessor = {
     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 ? " → 免疫成功" : " → 未免疫"));
+    if (isImmune) {
+      const chancePercent = Math.round(immuneChance * 100);
+      messages.push(`⚡ 【电能立场】生效：能量值≥30%，${chancePercent}%概率成功免疫非热能武器伤害`);
+    }
     return { isImmune, messages };
   }, "handleElectricField"),
   // 电能冲击波（能量回复）
@@ -3058,11 +3061,7 @@ var BattleEffectProcessor = {
     const maxHealAmount = 100;
     const actualHealAmount = Math.min(maxHealAmount, maxEnergy - currentEnergy);
     if (actualHealAmount <= 0) {
-      messages.push(`⚡ 【电能冲击波】生效：能量已达上限`);
-      return {
-        messages,
-        targetUpdates: null
-      };
+      return null;
     }
     const targetUpdates = {
       name: targetBoss.name,
@@ -3117,7 +3116,7 @@ var BattleEffectProcessor = {
   handleEnergyBlackhole: /* @__PURE__ */ __name(function(targetBoss) {
     const messages = [];
     if (!targetBoss.skills.includes("能量黑洞")) return null;
-    messages.push(`⚡ 【能量黑洞】生效：存在「能量黑洞」时，所受伤害降低20%`);
+    messages.push(`⚡ 【能量黑洞】生效：存在「能量黑洞」时，受到的伤害-20%`);
     return { nerfMultiplier: 0.2, messages };
   }, "handleEnergyBlackhole"),
   // 火焰异形（免疫伤害并回复生命值）
@@ -3140,8 +3139,7 @@ var BattleEffectProcessor = {
         // 生命值变化量
       }
     };
-    messages.push(`🔥 【火焰异形】生效：「${targetBoss.boss}」免疫火焰伤害`);
-    messages.push(`🔥 恢复${healAmount}点生命值`);
+    messages.push(`🔥 【火焰异形】生效：免疫火焰伤害并回复${healAmount}点生命值`);
     return {
       isImmune,
       messages,
@@ -3157,9 +3155,9 @@ var BattleEffectProcessor = {
     const maxHP = getMaxHPByName(targetBoss.name);
     const hpPercent = targetBoss.HP / maxHP;
     let nerfMultiplier = 0;
-    if (hpPercent < 0.5) {
+    if (hpPercent <= 0.5) {
       nerfMultiplier = 0.5;
-      messages.push(`💥 【庞兽狂暴】生效：生命值低于50%，狂暴状态下所受伤害降低50%`);
+      messages.push(`💥 【庞兽狂暴】生效：生命值≤50%，受到的伤害-50%`);
     }
     return { nerfMultiplier, messages };
   }, "handleColossalRampage"),
@@ -3177,17 +3175,15 @@ var BattleEffectProcessor = {
     if (!isFireDamage && currentStacks < maxStacks) {
       updates.skillStacksChanged = 1;
       const newStacks = currentStacks + 1;
-      messages.push(`🔥 【灼烧粘液】叠加：当前层数${newStacks}/${maxStacks}`);
+      messages.push(`🔥 【灼烧粘液】叠层：当前${newStacks}/20层`);
     }
     if (isFireDamage && currentStacks > 0) {
       const healAmount = currentStacks * 10;
       updates.hpChange = healAmount;
       updates.skillStacksChanged = -currentStacks;
+      messages.push(`🔥 【灼烧粘液】触发：消耗${currentStacks}层「灼烧粘液」，回复${healAmount}点生命值`);
       if (currentStacks >= 10) {
         isHighStackHeal = true;
-        messages.push(`🔥 【灼烧粘液】强力回复：消耗${currentStacks}层（≥10），回复${healAmount}点生命值！`);
-      } else {
-        messages.push(`🔥 【灼烧粘液】生效：消耗${currentStacks}层，回复${healAmount}点生命值`);
       }
     }
     if (Object.keys(updates).length > 0) {
@@ -3226,7 +3222,7 @@ var BattleEffectProcessor = {
         // 重置层数为0
       }
     };
-    messages.push(`🧪 【腐蚀胆汁】触发：灼烧粘液达到${currentStacks}层，为所有存活异形回复生命值`);
+    messages.push(`🧪 【腐蚀胆汁】触发：消耗${currentStacks}层「灼烧粘液」`);
     otherSurvivingBosses.forEach((otherBoss) => {
       const otherName = otherBoss.name;
       const healAmount = 1e3;
@@ -3235,7 +3231,7 @@ var BattleEffectProcessor = {
           name: otherName,
           updates: { hpChange: healAmount }
         });
-        messages.push(`🧪 【腐蚀胆汁】生效：为「${otherName}」回复${healAmount}点生命值`);
+        messages.push(`🧪 【腐蚀胆汁】触发：为「${otherName}」回复${healAmount}点生命值`);
       }
     });
     return {
@@ -3267,7 +3263,7 @@ var BattleEffectProcessor = {
         // 重置层数为0
       }
     };
-    messages.push(`🔥 【火焰吐息】触发：灼烧粘液达到${currentStacks}层，为所有存活异形回复20%最大生命值`);
+    messages.push(`🔥 【火焰吐息】触发：消耗${currentStacks}层「灼烧粘液」`);
     otherSurvivingBosses.forEach((otherBoss) => {
       const otherName = otherBoss.name;
       const maxHP = getMaxHPByName(otherName);
@@ -3277,7 +3273,7 @@ var BattleEffectProcessor = {
           name: otherName,
           updates: { hpChange: healAmount }
         });
-        messages.push(`🔥 【火焰吐息】生效：为「${otherName}」回复${healAmount}点生命值`);
+        messages.push(`🔥 【火焰吐息】触发：为「${otherName}」回复${healAmount}点生命值`);
       }
     });
     return {
@@ -3287,7 +3283,7 @@ var BattleEffectProcessor = {
     };
   }, "handleFlameBreath"),
   // 太阳耀斑 - 移除状态并获得免疫
-  handleSolarFlare: /* @__PURE__ */ __name(function(targetBoss, weaponName, damage, activeBosses) {
+  handleSolarFlare: /* @__PURE__ */ __name(function(targetBoss, weaponName, activeBosses) {
     const messages = [];
     let isImmune = false;
     let targetUpdates = null;
@@ -3298,25 +3294,29 @@ var BattleEffectProcessor = {
       (boss) => boss.name !== targetBoss.name && boss.isActive
     );
     const hasFearColdTag = targetBoss.tags.includes("惧寒") || false;
-    if (hasLivingOffspring || !hasFearColdTag) {
+    if (hasLivingOffspring) {
       return null;
     }
-    targetUpdates = {
-      name: targetBoss.name,
-      updates: {
-        tagsRemoved: ["惧寒"]
-      }
-    };
-    messages.push(`☀️ 【太阳耀斑】生效：无存活子代，移除「惧寒」状态`);
+    if (hasFearColdTag) {
+      targetUpdates = {
+        name: targetBoss.name,
+        updates: {
+          tagsRemoved: ["惧寒"]
+        }
+      };
+      messages.push(`☀️ 【太阳耀斑】触发：移除「惧寒」标签`);
+    }
     const isColdWeapon = weaponName === "零度之下";
     if (isColdWeapon) {
       isImmune = true;
-      messages.push(`☀️ 【太阳耀斑】触发：免疫寒冷伤害`);
+      messages.push(`☀️ 【太阳耀斑】生效：免疫寒冷伤害`);
     }
     return {
       isImmune,
       messages,
-      targetUpdates
+      targetUpdates,
+      tempMark: true
+      // 添加临时标记
     };
   }, "handleSolarFlare"),
   // 燃烧潜地 - 低生命回复
@@ -3342,7 +3342,8 @@ var BattleEffectProcessor = {
         // 回复生命值
       }
     };
-    messages.push(`🔥 【燃烧潜地】生效：生命值低于10%，立即回复${healAmount}点生命值（效果移除）`);
+    messages.push(`🔥 【燃烧潜地】触发：生命值≤10%，回复${healAmount}点生命值`);
+    messages.push(`🔥 【燃烧潜地】技能移除`);
     return {
       messages,
       targetUpdates
@@ -3368,7 +3369,7 @@ var BattleEffectProcessor = {
     if (nerfMultiplier > 0) {
       const reductionPercent = Math.round(nerfMultiplier * 100);
       const offspringMsg = hasLivingOffspring ? "（存在子代，额外加成）" : "";
-      messages.push(`💣 【炼狱爆弹】生效：灼烧粘液${currentStacks}层，获得${reductionPercent}%减伤${offspringMsg}`);
+      messages.push(`💣 【炼狱爆弹】生效：当前${currentStacks}层「灼烧粘液」，受到的伤害-${reductionPercent}%${offspringMsg}`);
     }
     return { nerfMultiplier, messages };
   }, "handleInfernalBomb"),
@@ -3392,10 +3393,10 @@ var BattleEffectProcessor = {
     ).length;
     if (otherLivingAliens > 0) {
       nerfMultiplier = 0.2;
-      messages.push(`🦖 【猎手异形】生效：存在其他存活异形，所受伤害降低20%`);
+      messages.push(`🦖 【猎手异形】生效：存在其他存活异形，受到的伤害-20%`);
     } else {
       buffMultiplier = 0.2;
-      messages.push(`🦖 【猎手异形】生效：无其他存活异形，所受伤害提升20%`);
+      messages.push(`🦖 【猎手异形】生效：无其他存活异形，受到的伤害+20%`);
     }
     return {
       buffMultiplier,
@@ -3413,9 +3414,9 @@ var BattleEffectProcessor = {
     }
     const maxHP = getMaxHPByName(targetBoss.name);
     const currentHP = targetBoss.HP;
-    if (currentHP < maxHP * 0.5) {
+    if (currentHP <= maxHP * 0.5) {
       nerfMultiplier = 0.5;
-      messages.push(`💥 【狂暴】生效：生命值低于50%，进入狂暴状态，所受伤害降低50%`);
+      messages.push(`💥 【狂暴】生效：生命值≤50%，受到的伤害-50%`);
     }
     return { nerfMultiplier, messages };
   }, "handleRampage"),
@@ -3430,7 +3431,7 @@ var BattleEffectProcessor = {
     const lastWeapon = targetBoss.lastWeaponName || null;
     if (lastWeapon && lastWeapon === weaponName) {
       nerfMultiplier = 0.8;
-      messages.push(`🎭 【伪装】生效：已适应武器「${weaponName}」，本次伤害降低80%`);
+      messages.push(`🎭 【伪装】生效：已适应武器「${weaponName}」，本次受到的伤害-80%`);
     } else {
       targetUpdates = {
         name: targetBoss.name,
@@ -3439,7 +3440,7 @@ var BattleEffectProcessor = {
           // 记录当前武器
         }
       };
-      messages.push(`🎭 【伪装】生效：记录新武器「${weaponName}」，下次同武器攻击伤害降低80%`);
+      messages.push(`🎭 【伪装】生效：记录新武器「${weaponName}」`);
     }
     return {
       nerfMultiplier,
@@ -3456,7 +3457,7 @@ var BattleEffectProcessor = {
     }
     if (Math.random() < 0.05) {
       isImmune = true;
-      messages.push(`💀 【致命一击】生效：5%概率免疫本次伤害`);
+      messages.push(`💀 【致命一击】生效：5%概率免疫伤害`);
     }
     return { isImmune, messages };
   }, "handleDeadlyHit"),
@@ -3481,13 +3482,8 @@ var BattleEffectProcessor = {
           updates: { hpChange: baseHealAmount }
         });
       }
-      messages.push(`🌬️ 【星界之风】为「${bossName}」回复${baseHealAmount}点生命值`);
+      messages.push(`🌬️ 【星界之风】触发：为「${bossName}」回复${baseHealAmount}点生命值`);
     });
-    if (doubleChance) {
-      messages.unshift(`🌬️ 【星界之风】生效：心灵狂热状态（触发概率10%）为所有存活异形回复生命值`);
-    } else {
-      messages.unshift(`🌬️ 【星界之风】生效：5%概率触发，为所有存活异形回复生命值`);
-    }
     return {
       messages,
       otherUpdates
@@ -3503,41 +3499,54 @@ var BattleEffectProcessor = {
     }
     const maxHP = getMaxHPByName(targetBoss.name);
     const hpPercent = targetBoss.HP / maxHP;
-    if (hpPercent < 0.5) {
+    if (hpPercent <= 0.5) {
       nerfMultiplier = 0.2;
       doubleAstralWind = true;
-      messages.push(`🧠 【心灵狂热】生效：生命值低于50%，进入心灵狂热状态，所受伤害降低20%，星界之风触发概率翻倍`);
+      messages.push(`🧠 【心灵狂热】生效：生命值≤50%，受到的伤害-20%，「星界之风」触发概率翻倍`);
     }
     return { nerfMultiplier, doubleAstralWind, messages };
   }, "handleMindFrenzy"),
-  /** 宇宙能量处理（伤害值转能量/生命） */
-  handleCosmicEnergy: /* @__PURE__ */ __name(function(targetBoss, activeBosses, damage) {
-    const messages = [];
-    let targetUpdates = null;
+  handleCosmicEnergy: /* @__PURE__ */ __name(function(targetBoss, damage) {
     if (!targetBoss.skills.includes("宇宙能量")) {
       return null;
     }
     const maxEnergy = getMaxEnergyByName(targetBoss.name);
     const currentEnergy = targetBoss.energy || 0;
     const energyToAdd = damage;
-    const updates = {};
+    if (energyToAdd <= 0) {
+      return null;
+    }
+    let energyGained = 0;
+    let overflowHeal = 0;
     if (currentEnergy + energyToAdd <= maxEnergy) {
-      updates.energyChange = energyToAdd;
-      messages.push(`🌌 【宇宙能量】生效：吸收伤害值，获得${energyToAdd}点能量`);
+      energyGained = energyToAdd;
     } else {
-      const energyGained = maxEnergy - currentEnergy;
+      energyGained = maxEnergy - currentEnergy;
+      overflowHeal = currentEnergy + energyToAdd - maxEnergy;
+    }
+    if (energyGained <= 0 && overflowHeal <= 0) {
+      return null;
+    }
+    const messages = [];
+    const updates = {};
+    let messageParts = [];
+    if (energyGained > 0) {
+      messageParts.push(`获得${energyGained}点能量`);
       updates.energyChange = energyGained;
-      const overflowHeal = currentEnergy + energyToAdd - maxEnergy;
+    }
+    if (overflowHeal > 0) {
+      messageParts.push(`${overflowHeal}点溢出伤害转为生命回复`);
       updates.hpChange = overflowHeal;
-      messages.push(`🌌 【宇宙能量】生效：获得${energyGained}点能量，${overflowHeal}点溢出伤害转为生命回复`);
     }
-    targetUpdates = {
-      name: targetBoss.name,
-      updates
-    };
+    if (messageParts.length > 0) {
+      messages.push(`🌌 【宇宙能量】生效：${messageParts.join("，")}`);
+    }
     return {
       messages,
-      targetUpdates
+      targetUpdates: {
+        name: targetBoss.name,
+        updates
+      }
     };
   }, "handleCosmicEnergy"),
   /** 复苏处理（免疫死亡并回复） */
@@ -3566,9 +3575,8 @@ var BattleEffectProcessor = {
         // 添加新技能
       }
     };
-    messages.push(`🔥 【复苏】生效：免疫致命伤害`);
-    messages.push(`🔥 回复${healAmount}点生命值和${energyGain}点能量`);
-    messages.push(`🔥 获得【灵能构造炉】技能，复苏效果移除`);
+    messages.push(`🔥 【复苏】生效：承受致命伤害时免疫死亡，回复${healAmount}点生命值和${energyGain}点能量，获得「灵能构造炉」技能`);
+    messages.push(`🔥 【复苏】技能移除`);
     return {
       messages,
       targetUpdates
@@ -3584,11 +3592,7 @@ var BattleEffectProcessor = {
     }
     const currentStacks = targetBoss.skillStacks || 0;
     if (currentStacks >= maxStacks) {
-      messages.push(`✨ 【光影之刃】已达到最大层数(${maxStacks})`);
-      return {
-        messages,
-        targetUpdates: null
-      };
+      return null;
     }
     targetUpdates = {
       name: targetBoss.name,
@@ -3597,21 +3601,21 @@ var BattleEffectProcessor = {
       }
     };
     const newStacks = currentStacks + 1;
-    messages.push(`✨ 【光影之刃】叠加：当前${newStacks}/${maxStacks}层`);
+    messages.push(`✨ 【光影之刃】生效：获得1层「光影之刃」`);
     return {
       messages,
       targetUpdates
     };
   }, "handleBladeOfLight"),
   /** 远古预兆处理（概率免疫能量伤害）- 增加boost参数 */
-  handleAncientOmen: /* @__PURE__ */ __name(function(targetBoss, weaponData, boost = 0) {
+  handleAncientOmen: /* @__PURE__ */ __name(function(targetBoss, weaponData, boost) {
     const messages = [];
     let isImmune = false;
     let targetUpdates = null;
     if (!targetBoss.skills.includes("远古预兆")) {
       return null;
     }
-    if (weaponData.type !== "能量武器") {
+    if (weaponData.type === "热能武器") {
       return null;
     }
     const baseProbability = 0.01;
@@ -3628,8 +3632,7 @@ var BattleEffectProcessor = {
         // 回复100点能量
       }
     };
-    messages.push(`🔮 【远古预兆】生效：${(actualProbability * 100).toFixed(2)}%概率免疫能量武器伤害`);
-    messages.push(`🔮 回复${energyGained}点能量`);
+    messages.push(`🔮 【远古预兆】触发：${(actualProbability * 100).toFixed(2)}%概率免疫非热能武器伤害，并回复${energyGained}点能量`);
     return {
       isImmune,
       messages,
@@ -3650,8 +3653,7 @@ var BattleEffectProcessor = {
     ancientOmenBoost = totalBoost;
     psychicForgeBoost = totalBoost;
     if (totalBoost > 0) {
-      messages.push(`⚡ 【闪电冲锋】生效：每层光影之刃提升0.5%概率`);
-      messages.push(`    → 当前${lightBladeStacks}层，远古预兆+${(ancientOmenBoost * 100).toFixed(1)}%，灵能构造炉+${(psychicForgeBoost * 100).toFixed(1)}%`);
+      messages.push(`⚡ 【闪电冲锋】生效：「光影之刃」当前${lightBladeStacks}层，「远古预兆」触发概率+${(ancientOmenBoost * 100).toFixed(1)}%，「灵能构造炉」触发概率+${(psychicForgeBoost * 100).toFixed(1)}%`);
     }
     return { ancientOmenBoost, psychicForgeBoost, messages };
   }, "handleLightningCharge"),
@@ -3668,13 +3670,13 @@ var BattleEffectProcessor = {
     const energyPercent = currentEnergy / maxEnergy;
     if (energyPercent >= 0.6) {
       nerfMultiplier = targetBoss.skillStacks * 0.1;
-      messages.push(`🚀 【超视距穿梭】生效：高能量状态(≥60%)，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
+      messages.push(`🚀 【超视距穿梭】生效：能量值≥60%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
     } else if (energyPercent >= 0.3) {
       nerfMultiplier = targetBoss.skillStacks * 0.05;
-      messages.push(`🚀 【超视距穿梭】生效：中能量状态(≥30%)，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
+      messages.push(`🚀 【超视距穿梭】生效：能量值≥30%，受到的伤害-${(nerfMultiplier * 100).toFixed(0)}%`);
     } else if (energyPercent <= 0.1) {
       buffMultiplier = targetBoss.skillStacks * 0.05;
-      messages.push(`🚀 【超视距穿梭】生效：低能量状态(≤10%)，受到的伤害+${(buffMultiplier * 100).toFixed(0)}%`);
+      messages.push(`🚀 【超视距穿梭】生效：能量值≤10%，受到的伤害+${(buffMultiplier * 100).toFixed(0)}%`);
     }
     return { nerfMultiplier, buffMultiplier, messages };
   }, "handleHyperRangeShift"),
@@ -3710,7 +3712,7 @@ var BattleEffectProcessor = {
         skillsAdded: [newSkill]
       }
     };
-    messages.push(`⚙️ 【灵能构造炉】生效：${(actualProbability * 100).toFixed(2)}%概率获得新技能「${newSkill}」`);
+    messages.push(`⚙️ 【灵能构造炉】触发：${(actualProbability * 100).toFixed(2)}%概率获得新技能「${newSkill}」`);
     return {
       messages,
       newSkill,
@@ -3724,7 +3726,7 @@ var BattleEffectProcessor = {
     if (!targetBoss.skills.includes("天启超载护盾")) {
       return null;
     }
-    if (Math.random() >= 0.05) {
+    if (Math.random() >= 0.1) {
       return null;
     }
     const baseHealAmount = (targetBoss.skillStacks || 0) * 10;
@@ -3737,9 +3739,8 @@ var BattleEffectProcessor = {
           updates: { hpChange: baseHealAmount }
         });
       }
-      messages.push(`🛡️ 【天启超载护盾】为「${bossName}」回复${baseHealAmount}点生命值`);
+      messages.push(`🛡️ 【天启超载护盾】触发：为「${bossName}」回复${baseHealAmount}点生命值`);
     });
-    messages.unshift(`🛡️ 【天启超载护盾】生效：5%概率触发，为所有存活异形回复生命值`);
     return {
       messages,
       otherUpdates
@@ -3755,11 +3756,7 @@ var BattleEffectProcessor = {
     }
     const currentStacks = targetBoss.skillStacks || 0;
     if (currentStacks >= maxStacks) {
-      messages.push(`🌀 【塌缩脉冲】生效：层数已达上限(${maxStacks})`);
-      return {
-        messages,
-        targetUpdates: null
-      };
+      return null;
     }
     targetUpdates = {
       name: targetBoss.name,
@@ -3768,7 +3765,7 @@ var BattleEffectProcessor = {
       }
     };
     const newStacks = currentStacks + 1;
-    messages.push(`🌀 【塌缩脉冲】生效：额外叠加1层光影之刃，当前${newStacks}/${maxStacks}层`);
+    messages.push(`🌀 【塌缩脉冲】生效：额外获得1层「光影之刃」`);
     return {
       messages,
       targetUpdates
@@ -3782,8 +3779,8 @@ var BattleEffectProcessor = {
       return null;
     }
     nerfMultiplier = 1;
-    messages.push(`💣 【地毯式轰炸】生效：获得100%减伤`);
-    return { nerfMultiplier, messages };
+    messages.push(`💣 【地毯式轰炸】生效：受到的伤害-100%`);
+    return { nerfMultiplier, messages, tempMark: true };
   }, "handleCarpetBombing"),
   /** 轰炸引导处理（层数相关能量回复） */
   handleBombardmentGuide: /* @__PURE__ */ __name(function(targetBoss) {
@@ -3792,7 +3789,7 @@ var BattleEffectProcessor = {
     if (!targetBoss.skills.includes("轰炸引导")) {
       return null;
     }
-    if (Math.random() >= 0.05) {
+    if (Math.random() >= 0.1) {
       return null;
     }
     const currentStacks = targetBoss.skillStacks || 0;
@@ -3803,7 +3800,7 @@ var BattleEffectProcessor = {
         energyChange: energyGained
       }
     };
-    messages.push(`🎯 【轰炸引导】生效：5%概率触发，获得${energyGained}点能量（基于${currentStacks}层光影之刃）`);
+    messages.push(`🎯 【轰炸引导】触发：当前${currentStacks}层「光影之刃」，获得${energyGained}点能量`);
     return {
       messages,
       targetUpdates
@@ -3817,9 +3814,9 @@ var BattleEffectProcessor = {
     const effectiveLayers = Math.min(currentLayers, 20);
     const buffMultiplier = effectiveLayers * 0.025;
     if (effectiveLayers > 0) {
-      messages.push(`☢️ 【辐射增伤】：当前${currentLayers}层，所受伤害提升${(effectiveLayers * 2.5).toFixed(1)}%`);
+      messages.push(`☢️ 【辐射增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
       if (currentLayers > 20) {
-        messages.push(`☢️ 注意：超过20层的辐射无效，不会提供额外增伤`);
+        messages.push(`☢️ 注意：超过20层的辐射不会提供额外增伤`);
       }
     }
     let targetUpdates = null;
@@ -3834,7 +3831,7 @@ var BattleEffectProcessor = {
         }
       };
       const newLayers = currentLayers + 1;
-      messages.push(`☢️ 满足辐射条件，获得1层"辐射"效果，累计${newLayers}层`);
+      messages.push(`☢️ 【伽马枪】武器效果：获得1层「辐射」`);
       layerAdded = true;
     }
     return {
@@ -3853,9 +3850,9 @@ var BattleEffectProcessor = {
     const effectiveLayers = Math.min(currentLayers, 20);
     const buffMultiplier = effectiveLayers * 0.025;
     if (effectiveLayers > 0) {
-      messages.push(`❄️ 【寒冷增伤】：当前${currentLayers}层，所受伤害提升${(effectiveLayers * 2.5).toFixed(1)}%`);
+      messages.push(`❄️ 【寒冷增伤】：当前${currentLayers}层，受到的伤害+${(effectiveLayers * 2.5).toFixed(1)}%`);
       if (currentLayers > 20) {
-        messages.push(`❄️ 注意：超过20层的寒冷无效，不会提供额外增伤`);
+        messages.push(`❄️ 注意：超过20层的寒冷不会提供额外增伤`);
       }
     }
     let targetUpdates = null;
@@ -3868,7 +3865,7 @@ var BattleEffectProcessor = {
         }
       };
       const newLayers = currentLayers + 1;
-      messages.push(`❄️ 满足寒冷条件，获得1层"寒冷"效果，累计${newLayers}层`);
+      messages.push(`❄️【零度之下】武器效果： 获得1层「寒冷」`);
       layerAdded = true;
     }
     return {
@@ -3903,7 +3900,7 @@ var BattleEffectProcessor = {
     }
     const weaponDisplayName = weaponName === "弧焊枪" ? "弧焊枪" : "DG-3电弧步枪";
     if (success) {
-      messages.push(`⚡ 【${weaponDisplayName}】武器效果：消耗目标${drainValue}点能量`);
+      messages.push(`⚡ 【${weaponDisplayName}】武器效果：消耗${drainValue}点能量`);
     }
     return {
       messages,
@@ -3934,7 +3931,7 @@ var BattleEffectProcessor = {
       };
     }
     if (reductionSuccess) {
-      messages.push(`⚡ 【${weaponName}】武器效果：使${targetBoss.name}的技能层数减少${reductionAmount}层`);
+      messages.push(`⚡ 【${weaponName}】武器效果：技能层数减少${reductionAmount}层`);
     }
     return {
       messages,
@@ -3957,178 +3954,192 @@ function applyPassiveEffects(targetBoss, activeBosses, weaponName, damage, ignor
   let ancientOmenBoost = 0;
   let psychicForgeBoost = 0;
   let doubleAstralWind = false;
+  let isolatedImmunityMark = false;
+  const processEffect = /* @__PURE__ */ __name((effect, ...args) => {
+    const result = effect(...args);
+    if (!result) return null;
+    messages.push(...result.messages || []);
+    if (result.targetUpdates) {
+      updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
+    }
+    if (result.otherUpdates) {
+      for (const update of result.otherUpdates) {
+        updateStatsByName(update.name, update.updates);
+      }
+    }
+    return result;
+  }, "processEffect");
   const lightningResult = BattleEffectProcessor.handleLightningCharge(targetBoss);
   if (lightningResult) {
+    ancientOmenBoost = lightningResult.ancientOmenBoost || 0;
+    psychicForgeBoost = lightningResult.psychicForgeBoost || 0;
     messages.push(...lightningResult.messages);
-    ancientOmenBoost += lightningResult.ancientOmenBoost || 0;
-    psychicForgeBoost += lightningResult.psychicForgeBoost || 0;
   }
   const coldImmuneEffects = [
-    BattleEffectProcessor.handleFrostEvolution,
-    BattleEffectProcessor.handleColdAdaptation,
-    BattleEffectProcessor.handleSolarFlare
+    {
+      effect: BattleEffectProcessor.handleFrostEvolution,
+      args: [targetBoss, weaponName, damage]
+    },
+    {
+      effect: BattleEffectProcessor.handleColdAdaptation,
+      args: [targetBoss, weaponName]
+    }
   ];
   const fireImmuneEffects = [
-    BattleEffectProcessor.handleFlameAlien
+    {
+      effect: BattleEffectProcessor.handleFlameAlien,
+      args: [targetBoss, weaponName, damage]
+    }
   ];
-  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 chanceImmuneEffects = [
+    {
+      effect: BattleEffectProcessor.handleDeadlyHit,
+      args: [targetBoss]
+    },
+    {
+      effect: BattleEffectProcessor.handleElectricField,
+      args: [targetBoss, weaponData]
+    },
+    {
+      effect: BattleEffectProcessor.handleAncientOmen,
+      args: [targetBoss, weaponData, ancientOmenBoost]
     }
+  ];
+  const allImmuneEffects = [...coldImmuneEffects, ...fireImmuneEffects, ...chanceImmuneEffects];
+  for (const immuneEffect of allImmuneEffects) {
+    const result = processEffect(immuneEffect.effect, ...immuneEffect.args);
+    if (result?.isImmune) immune = true;
   }
-  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 solarFlareResult = BattleEffectProcessor.handleSolarFlare(targetBoss, weaponName, activeBosses);
+  if (solarFlareResult) {
+    isolatedImmunityMark = solarFlareResult.tempMark || false;
+    if (solarFlareResult.isImmune) immune = true;
+    messages.push(...solarFlareResult.messages);
+    if (solarFlareResult.targetUpdates) {
+      updateStatsByName(solarFlareResult.targetUpdates.name, solarFlareResult.targetUpdates.updates);
     }
   }
-  const 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);
-        }
-      }
-    } else {
-      const result = effect(targetBoss, weaponData);
-      if (result && result.isImmune) {
-        immune = true;
-        messages.push(...result.messages);
-      }
+  const carpetBombResult = processEffect(BattleEffectProcessor.handleCarpetBombing, targetBoss);
+  if (carpetBombResult) {
+    isolatedImmunityMark = carpetBombResult.tempMark || false;
+    if (carpetBombResult.nerfMultiplier) {
+      totalNerfMultiplier += carpetBombResult.nerfMultiplier;
     }
+    messages.push(...carpetBombResult.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
+    // 单参数效果
+    { effect: BattleEffectProcessor.handleWeakForm, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleAlienShell, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleFrostHell, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleStressShellI, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleStressShellII, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleVirusCloud, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleEnergyBlackhole, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleColossalRampage, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleVomit, args: [targetBoss] },
+    // 双参数效果
+    { effect: BattleEffectProcessor.handleStructuralArmor, args: [targetBoss, weaponData] },
+    { effect: BattleEffectProcessor.handleDisguise, args: [targetBoss, weaponName] },
+    // 多参数效果
+    { effect: BattleEffectProcessor.handleIsolated, args: [targetBoss, activeBosses, isolatedImmunityMark] },
+    { effect: BattleEffectProcessor.handleInfectedSpaceStation, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleInfernalBomb, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleHunterAlien, args: [targetBoss, activeBosses, weaponName] },
+    { effect: BattleEffectProcessor.handleRampage, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleHyperRangeShift, args: [targetBoss] }
   ];
-  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);
-    }
+  for (const effectItem of damageAdjustEffects) {
+    const result = processEffect(effectItem.effect, ...effectItem.args);
     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 (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
+      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
+      bileDetonationTrigger ||= result.bileDetonationTrigger === true;
     }
   }
-  const stateChangeEffects = [
-    BattleEffectProcessor.handleVampireSaliva,
-    BattleEffectProcessor.handleBladeOfLight,
-    BattleEffectProcessor.handleSuperconductor
+  const mindFrenzyResult = BattleEffectProcessor.handleMindFrenzy(targetBoss);
+  if (mindFrenzyResult) {
+    messages.push(...mindFrenzyResult.messages);
+    if (mindFrenzyResult.nerfMultiplier) {
+      totalNerfMultiplier += mindFrenzyResult.nerfMultiplier;
+    }
+    doubleAstralWind = mindFrenzyResult.doubleAstralWind || false;
+  }
+  const layerDependentEffects = [
+    { effect: BattleEffectProcessor.handleVampireSaliva, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBloodlust, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBladeOfLight, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleCollapsingPulse, args: [targetBoss] }
   ];
-  for (const effect of stateChangeEffects) {
-    const result = effect(targetBoss);
+  for (const effectItem of layerDependentEffects) {
+    const result = processEffect(effectItem.effect, ...effectItem.args);
     if (result) {
-      messages.push(...result.messages);
-      if (result.targetUpdates) {
-        updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
-      }
+      if (result.buffMultiplier !== void 0) totalBuffMultiplier += result.buffMultiplier;
+      if (result.nerfMultiplier !== void 0) totalNerfMultiplier += result.nerfMultiplier;
     }
   }
+  const stateChangeEffects = [
+    { effect: BattleEffectProcessor.handleSuperconductor, args: [targetBoss] }
+  ];
+  for (const effectItem of stateChangeEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
+  const healingEffects = [
+    { effect: BattleEffectProcessor.handleFrostRegeneration, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFrostAura, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleSentryGun, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleSurvivalInstinctI, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleSurvivalInstinctII, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleMoldGrowth, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleElectricShockwave, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handlePulse, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFeeding, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleBurningBurrow, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleRevival, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleCosmicEnergy, args: [targetBoss, damage] },
+    { effect: BattleEffectProcessor.handleBombardmentGuide, args: [targetBoss] },
+    { effect: BattleEffectProcessor.handleOverdriveShield, args: [targetBoss, activeBosses] }
+  ];
+  for (const effectItem of healingEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
   const burningSlimeResult = BattleEffectProcessor.handleBurningSlime(targetBoss, weaponName);
   if (burningSlimeResult) {
     messages.push(...burningSlimeResult.messages);
     if (burningSlimeResult.targetUpdates) {
       updateStatsByName(burningSlimeResult.targetUpdates.name, burningSlimeResult.targetUpdates.updates);
     }
-    bileDetonationTrigger = burningSlimeResult.isHighStackHeal;
+    bileDetonationTrigger = burningSlimeResult.isHighStackHeal || false;
   }
-  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
+  const bileEffects = [
+    { effect: BattleEffectProcessor.handleCorrosiveBile, args: [targetBoss, activeBosses] },
+    { effect: BattleEffectProcessor.handleFlameBreath, args: [targetBoss, activeBosses] }
   ];
-  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);
-    }
-    if (result) {
-      messages.push(...result.messages);
-      if (result.targetUpdates) {
-        updateStatsByName(result.targetUpdates.name, result.targetUpdates.updates);
-      }
-      if (result.otherUpdates) {
-        for (const update of result.otherUpdates) {
-          updateStatsByName(update.name, update.updates);
-        }
+  for (const effectItem of bileEffects) {
+    processEffect(effectItem.effect, ...effectItem.args);
+  }
+  const astralWindResult = BattleEffectProcessor.handleAstralWind(
+    targetBoss,
+    activeBosses,
+    doubleAstralWind
+  );
+  if (astralWindResult) {
+    messages.push(...astralWindResult.messages);
+    if (astralWindResult.otherUpdates) {
+      for (const update of astralWindResult.otherUpdates) {
+        updateStatsByName(update.name, update.updates);
       }
     }
   }
-  const mindFrenzyResult = BattleEffectProcessor.handleMindFrenzy(targetBoss);
-  if (mindFrenzyResult) {
-    messages.push(...mindFrenzyResult.messages);
-    totalNerfMultiplier += mindFrenzyResult.nerfMultiplier || 0;
-    doubleAstralWind = mindFrenzyResult.doubleAstralWind || false;
+  const psychicForgeResult = BattleEffectProcessor.handlePsychicForge(
+    targetBoss,
+    psychicForgeBoost
+  );
+  if (psychicForgeResult) {
+    messages.push(...psychicForgeResult.messages);
+    if (psychicForgeResult.targetUpdates) {
+      updateStatsByName(psychicForgeResult.targetUpdates.name, psychicForgeResult.targetUpdates.updates);
+    }
   }
   const radiationResult = BattleEffectProcessor.handleRadiationEffect(targetBoss, weaponName);
   if (radiationResult) {
@@ -4158,7 +4169,7 @@ function applyPassiveEffects(targetBoss, activeBosses, weaponName, damage, ignor
     if (energyDrainResult.targetUpdates) {
       updateStatsByName(energyDrainResult.targetUpdates.name, energyDrainResult.targetUpdates.updates);
     }
-    energyDrained = energyDrainResult.success;
+    energyDrained = energyDrainResult.success || false;
   }
   const layerReduceResult = BattleEffectProcessor.handleWeaponLayerReduction(targetBoss, weaponName);
   if (layerReduceResult) {
@@ -4166,48 +4177,19 @@ function applyPassiveEffects(targetBoss, activeBosses, weaponName, damage, ignor
     if (layerReduceResult.targetUpdates) {
       updateStatsByName(layerReduceResult.targetUpdates.name, layerReduceResult.targetUpdates.updates);
     }
-    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 psychicForgeResult = BattleEffectProcessor.handlePsychicForge(targetBoss, psychicForgeBoost);
-  if (psychicForgeResult) {
-    messages.push(...psychicForgeResult.messages);
-    if (psychicForgeResult.targetUpdates) {
-      updateStatsByName(psychicForgeResult.targetUpdates.name, psychicForgeResult.targetUpdates.updates);
-    }
+    layerReduced = layerReduceResult.reductionSuccess || false;
   }
   let finalDamage = damage;
   if (!immune) {
     let adjustedNerfMultiplier = totalNerfMultiplier * (1 - ignoreRate);
-    if (ignoreRate > 0 && totalNerfMultiplier > 0) {
-      messages.push(`🗡️ 无视减伤: 无视了${(ignoreRate * 100).toFixed(1)}%减伤效果`);
-      messages.push(`  减伤系数由${(totalNerfMultiplier * 100).toFixed(1)}%降低至${(adjustedNerfMultiplier * 100).toFixed(1)}%`);
-    }
     const damageMultiplier = 1 + totalBuffMultiplier - adjustedNerfMultiplier;
     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
       });
     }
-  }
-  if (immune) {
+  } else {
     finalDamage = 0;
   }
   return {
@@ -4399,7 +4381,6 @@ __name(handlePrimaryAttack, "handlePrimaryAttack");
 async function handleScatterAttack(ctx, session, handle, config, equippedWeapon, targetBoss, weaponName, activeBosses) {
   const secondaryTargets = activeBosses.filter((boss) => boss.name !== targetBoss.name);
   const scatterEffectMessages = [];
-  const ignoreMessage = [];
   const extraDamages = [];
   const actuallyDead = [];
   const taskUpdates = [];
@@ -4447,14 +4428,12 @@ async function handleScatterAttack(ctx, session, handle, config, equippedWeapon,
     }
     const isDead = currentHP <= 0;
     scatterEffectMessages.push(...EffectProcessor.messages.map((m) => ` 对 ${secondaryTarget.name} ${m}`));
-    ignoreMessage.push(...ignoreReduction.messages.map((m) => ` 对 ${secondaryTarget.name} ${m}`));
     if (isDead) {
       actuallyDead.push(secondaryTarget.name);
     }
   }
   return {
     scatterEffectMessages,
-    ignoreMessage,
     extraDamages,
     actuallyDead,
     taskUpdates
@@ -4555,7 +4534,7 @@ async function updateSignRecord(ctx, handle, reward) {
 }
 __name(updateSignRecord, "updateSignRecord");
 function buildResultMessage(session, weaponName, targetBoss, primaryResult, scatterResult, finalReward, careerMessage, techMessage, redcrystalMessage) {
-  const maxHP = getMaxHPByName2(targetBoss.name);
+  const maxHP = getMaxHPByName(targetBoss.name);
   const messages = [
     `🔥 ${session.username} 使用武器 ${weaponName} 对 ${targetBoss.name} 发起攻击！`,
     ...primaryResult.effectMessage.length > 0 ? [
@@ -4574,10 +4553,6 @@ ${primaryResult.passiveMessages.map((m) => `▸ ${m}`).join("\n")}`
   ];
   if (scatterResult) {
     messages.push(
-      ...scatterResult.ignoreMessage.length > 0 ? [
-        `🗡️ 无视减伤效果：
-${scatterResult.ignoreMessage.map((m) => `▸ ${m}`).join("\n")}`
-      ] : [],
       `⚡ 散射效果：
 ${scatterResult.scatterEffectMessages.map((m) => `▸ ${m}`).join("\n")}`,
       `散射伤害：`,
@@ -4651,38 +4626,10 @@ 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);
+  const maxHP = getMaxHPByName(stats.name);
+  const maxEnergy = getMaxEnergyByName(stats.name);
   if (!bossData || bossData.length === 0) {
     return;
   }
@@ -4742,13 +4689,13 @@ async function handleIgnoreReductionEffects(ctx, handle, weaponName, targetBoss)
   const handleWeaponEffect = /* @__PURE__ */ __name(() => {
     if (weaponName === "光剑") {
       ignoreEffects.push(1);
-      messages.push(`⚔️ 【光剑】武器效果：无视目标100%减伤效果`);
+      messages.push(`⚔️ 【光剑】武器效果：无视100%减伤效果`);
     } else if (weaponName === "M4AE脉冲步枪") {
       ignoreEffects.push(0.8);
-      messages.push(`🔫 【M4AE脉冲步枪】武器效果：无视目标80%减伤效果`);
+      messages.push(`🔫 【M4AE脉冲步枪】武器效果：无视80%减伤效果`);
     } else if (weaponName === "粒子相位枪" && targetBoss?.tags.includes("护盾")) {
       ignoreEffects.push(0.5);
-      messages.push(`⚡ 【粒子相位枪】武器效果：无视护盾目标50%减伤效果`);
+      messages.push(`⚡ 【粒子相位枪】武器效果：无视50%减伤效果`);
     }
   }, "handleWeaponEffect");
   const handlePiercingMod = /* @__PURE__ */ __name(async () => {
@@ -4761,7 +4708,7 @@ async function handleIgnoreReductionEffects(ctx, handle, weaponName, targetBoss)
     });
     if (equippedWeapon?.installedMods?.includes("破甲模块")) {
       ignoreEffects.push(0.2);
-      messages.push(`⚡ 【破甲模块】生效：无视目标20%减伤效果`);
+      messages.push(`⚡ 【破甲模块】生效：无视20%减伤效果`);
     }
   }, "handlePiercingMod");
   handleWeaponEffect();
@@ -4775,11 +4722,11 @@ async function handleIgnoreReductionEffects(ctx, handle, weaponName, targetBoss)
     });
     if (radarMask?.quantity > 0) {
       ignoreEffects.push(0.1);
-      messages.push(`🛰️ 【雷达面罩】生效：无视目标10%减伤效果`);
+      messages.push(`🛰️ 【雷达面罩】生效：无视10%减伤效果`);
     }
     if (careerData.career === "猩红杀手" && weaponName === "侦察步枪") {
       ignoreEffects.push(0.2);
-      messages.push(`🎯 【猩红杀手】职业效果：无视目标20%减伤效果`);
+      messages.push(`🎯 【猩红杀手】职业效果：无视20%减伤效果`);
     }
   }, "handleCareerEffects");
   await handleCareerEffects();
@@ -7133,10 +7080,14 @@ ${validTypes.join("、")}`;
       let discountRate = 0;
       if (careerData?.group === "人类联盟") {
         if (modInfo.isExclusive) {
-          if (techLevel >= 2 && isCareerMatch) discountRate = 10;
+          if (techLevel >= 2) {
+            const baseDiscount = 5;
+            const careerDiscount = 10;
+            discountRate = Math.max(baseDiscount, careerDiscount);
+          }
         } else {
-          const baseDiscount = [5, 10][techLevel - 1] || 0;
-          const careerDiscount = techLevel >= 1 && isCareerMatch ? [10, 20][techLevel - 1] : 0;
+          const baseDiscount = 5;
+          const careerDiscount = 10;
           discountRate = Math.max(baseDiscount, careerDiscount);
         }
       }