refactor: 重构复活机制，将复活逻辑整合到dead触发组

1.  新增SkillOverrides的revive_hp和revive_count配置项，替代原独立复活字段
2.  移除所有revive相关的旧配置、解析函数和UI展示逻辑
3.  调整战斗逻辑，从dead触发组的overrides中读取复活配置
4.  更新文档说明，统一复活机制的配置方式
5.  清理冗余的导入和类型定义

assets/script/game/common/HeroSkillText.ts

@@ -25,8 +25,8 @@
  */
 import {
     HeroInfo, heroInfo, SkillTriggerType, SkillTriggerName, HSkillInfo, LvTriggerEntry,
-    TriggerGrouped, resolveSkillOverrides, resolveTriggerByLv, resolveFieldByLv, resolveReviveByLv,
+    TriggerGrouped, resolveSkillOverrides, resolveTriggerByLv, resolveFieldByLv,
-    getGroupedTriggerName, getFieldSkillName, getReviveSkillName,
+    getGroupedTriggerName, getFieldSkillName,
 } from "./config/heroSet";
 import { SkillSet, mergeSkillParams, SkillConfig, SkillKind, TGroup, FieldSkillSet } from "./config/SkillSet";
 import { BuffList } from "./config/BuffSet";
@@ -219,12 +219,16 @@ export function buildHeroSkillDesc(heroUuid: number, showName: boolean = true, s
         lines.push(`${nameSeg(getFieldSkillName(hero, entry.uuid))}${desc.verb}${valueRich(val)}`);
     }
 
-    // ---- 复活（revive）：次数复刻战斗公式 r_num + floor((lv-1)*upr) ----
+    // ---- 复活（已纳入 dead 触发组）：从 dead 配置提取 revive_hp / revive_count ----
-    const revive = resolveReviveByLv(hero.revive, lv);
+    for (const item of resolveTriggerByLv(hero.dead, lv)) {
-    if (revive) {
+        const reviveHp = item.overrides?.revive_hp;
-        const count = revive.r_num + Math.floor((lv - 1) * revive.upr);
+        const reviveCount = item.overrides?.revive_count ?? 0;
-        const hpPct = SkillSet[revive.s_uuid]?.ap ?? 0;
+        if (reviveHp === undefined || reviveCount <= 0) continue;
-        lines.push(`${nameSeg(getReviveSkillName(hero, revive.s_uuid))}每回合可复活${valueRich(count)}次, 死亡后以${valueRich(`${Math.round(hpPct)}%`)}生命原地重生`);
+        const base = SkillSet[item.s_uuid];
+        if (!base) continue;
+        const skill = mergeSkillParams(base, item.overrides);
+        const text = `每回合可复活${valueRich(reviveCount)}次, 死亡后以${valueRich(`${Math.round(reviveHp)}%`)}生命原地重生`;
+        lines.push(`${nameSeg(getGroupedTriggerName(hero.dead!, item.s_uuid))}${SkillTriggerName[SkillTriggerType.Dead]}, ${text}`);
     }
 
     return lines.join("\n");
@@ -392,32 +396,40 @@ function collectFieldTierLines(hero: heroInfo, fieldUuid: number): HeroSkillTier
 }
 
 /**
- * 收集复活技能分档行（hero.revive 各英雄等级档，无 s_lv 概念，按档位序号编号）。
+ * 收集复活技能分档行（已纳入 dead 触发组，从 dead[skillUuid] 提取 revive_hp / revive_count）。
- * slv1 给完整效果（复活次数 + 重生血量）；slv2+ 给复活次数变化。
+ * slv1 给完整效果（复活次数 + 重生血量）；slv2+ 给复活次数/血量变化。
  * 档位配置了 desc 时直接采用。
  */
 function collectReviveTierLines(hero: heroInfo, sUuid: number): HeroSkillTierLine[] {
-    const matched = (hero.revive ?? [])
+    const entries = hero.dead?.[sUuid];
-        .filter(e => e.s_uuid === sUuid)
+    if (!entries?.length) return [];
+
+    // 筛选带复活参数的档位，按 lv 升序
+    const matched = entries
+        .filter(e => e.overrides?.revive_hp !== undefined && (e.overrides?.revive_count ?? 0) > 0)
         .sort((a, b) => a.lv - b.lv);
     if (matched.length === 0) return [];
 
     const lines: HeroSkillTierLine[] = [];
     let prevCount: number | undefined;
+    let prevHp: number | undefined;
     matched.forEach((e, i) => {
-        // 复活次数复刻战斗公式：r_num + floor((英雄等级-1)*upr)
+        const count = e.overrides!.revive_count!;
-        const count = e.r_num + Math.floor((e.lv - 1) * e.upr);
+        const hpPct = Math.round(e.overrides!.revive_hp!);
-        const hpPct = Math.round(SkillSet[e.s_uuid]?.ap ?? 0);
         if (e.desc) {
             lines.push({ sLv: i + 1, heroLv: e.lv, text: e.desc });
         } else if (i === 0) {
             lines.push({ sLv: 1, heroLv: e.lv, text: `每回合可复活${valueRich(count)}次, 死亡后以${valueRich(`${hpPct}%`)}生命原地重生` });
-        } else if (prevCount !== undefined && count !== prevCount) {
+        } else if (prevCount !== undefined && (count !== prevCount || hpPct !== prevHp)) {
-            lines.push({ sLv: i + 1, heroLv: e.lv, text: `复活次数${valueRich(prevCount)}次提升至${valueRich(count)}次` });
+            const parts: string[] = [];
+            if (count !== prevCount) parts.push(`复活次数${valueRich(prevCount)}次提升至${valueRich(count)}次`);
+            if (hpPct !== prevHp) parts.push(`回血比例${valueRich(prevHp)}%提升至${valueRich(hpPct)}%`);
+            lines.push({ sLv: i + 1, heroLv: e.lv, text: parts.join("，") });
         } else {
             lines.push({ sLv: i + 1, heroLv: e.lv, text: "无变化" });
         }
         prevCount = count;
+        prevHp = hpPct;
     });
     return lines;
 }
@@ -487,7 +499,7 @@ function buildTierLines(tiers: ISkillTierInfo[], triggerLabel: string): HeroSkil
  *   1. hero.skills[skillUuid]   —— 普攻/大招
  *   2. 5 类触发技能组            —— call/dead/fstart/atking/atked
  *   3. hero.field               —— 驻场光环词条（FieldSkillSet uuid）
- *   4. hero.revive              —— 复活技能（SkillSet uuid）
+ *   4. hero.dead 中的复活技能    —— 已纳入 dead 触发组（revive_hp / revive_count）
  *   均未命中返回 []。
  *
  * Why: 同一底座技能可能被多个英雄以不同 overrides 引用，必须以英雄语境取档；
@@ -503,9 +515,8 @@ export function buildHeroSkillTierLines(heroUuid: number, skillUuid: number, slo
     const hero = HeroInfo[heroUuid];
     if (!hero) return [];
 
-    // 槽位指定：光环/复活结构特殊直接生成行；触发组走统一档位结构
+    // 槽位指定：光环结构特殊直接生成行；触发组走统一档位结构（复活已纳入 dead）
     if (slot === SkillTriggerType.Field) return collectFieldTierLines(hero, skillUuid);
-    if (slot === SkillTriggerType.Revive) return collectReviveTierLines(hero, skillUuid);
     if (slot !== undefined) {
         const hit = collectTriggerTiers(hero, slot, skillUuid);
         return hit ? buildTierLines(hit.tiers, hit.label) : [];
@@ -530,12 +541,11 @@ export function buildHeroSkillTierLines(heroUuid: number, skillUuid: number, slo
         }
     }
 
-    // 光环/复活路径（无 ISkillTierInfo 中间结构，直接生成 HeroSkillTierLine）
+    // 光环路径（无 ISkillTierInfo 中间结构，直接生成 HeroSkillTierLine）
     if (tiers.length === 0) {
         const fieldLines = collectFieldTierLines(hero, skillUuid);
         if (fieldLines.length > 0) return fieldLines;
-        const reviveLines = collectReviveTierLines(hero, skillUuid);
+        // 复活已纳入 dead 触发组，通过 dead 路径处理
-        if (reviveLines.length > 0) return reviveLines;
         return [];
     }
 
@@ -580,9 +590,9 @@ function resolveTriggerSkillName(hero: heroInfo, skillUuid: number): string {
     if (hero.field?.some(e => e.uuids.some(u => u.uuid === skillUuid))) {
         return getFieldSkillName(hero, skillUuid);
     }
-    // 复活技能：名称取英雄语境（LvReviveEntry.name 优先，回退固定称谓）
+    // 复活技能：名称取英雄语境（dead 组名，回退底座名）
-    if (hero.revive?.some(e => e.s_uuid === skillUuid)) {
+    if (hero.dead?.[skillUuid]?.length) {
-        return getReviveSkillName(hero, skillUuid);
+        return getGroupedTriggerName(hero.dead, skillUuid);
     }
     return SkillSet[skillUuid]?.name ?? "";
 }

assets/script/game/common/config/SkillSet.ts

@@ -184,6 +184,10 @@ export interface SkillOverrides {
     is_accel?: boolean;
     /** 单次施法额外释放次数（0=单次，1=双发，2=三发；弹道由 resolveRepeatCastTargetPos 分散上/中/下三路） */
     num?: number;
+    /** 复活回血比例（%），有值表示死亡时触发复活（仅 dead 触发有效） */
+    revive_hp?: number;
+    /** 复活次数上限，配合 revive_hp 使用（仅 dead 触发有效） */
+    revive_count?: number;
 }
 
 /**

assets/script/game/common/config/heroSet.ts

@@ -1,4 +1,4 @@
-import { v3 } from "cc"
+import { v3 } from "cc"
 import { BoxSet, FacSet, FightSet } from "./GameSet"
 import { SkillOverrides, TGroup, SkillSet, FieldSkillSet, SkillConfig, SkillKind, FieldSkillConfig, FieldSkillType, mergeSkillParams } from "./SkillSet"
 import { BuffList, BuffConfig, ModOp } from "./BuffSet"
@@ -285,17 +285,9 @@ export function getFieldSkillName(hero: heroInfo | undefined, uuid: number): str
 }
 
 /**
- * 查询复活技能的对外展示名（英雄语境，LvReviveEntry.name 优先，缺省回退固定称谓"凤凰涅槃"）。
+ * 复活已纳入 dead 触发组：通过 SkillOverrides.revive_hp / revive_count 配置，
- * Why: 名称收敛进 heroSet 英雄配置，复活底座 6501 在不同英雄下可有特色名（如"回光返照"）。
+ * 不再需要独立的 revive 字段和解析函数。
- * @param hero 英雄配置（含 revive 档位的 heroInfo）
- * @param sUuid 复活底座技能 uuid（指向 SkillSet 6501）
  */
-export function getReviveSkillName(hero: heroInfo | undefined, sUuid: number): string {
-    for (const e of hero?.revive ?? []) {
-        if (e.s_uuid === sUuid && e.name) return e.name;
-    }
-    return "凤凰涅槃";
-}
 
 /**
  * 英雄/怪物基础信息接口
@@ -322,7 +314,6 @@ export interface heroInfo {
     [SkillTriggerType.Field]?: LvFieldEntry[];     // 驻场光环（按 lv 升序，运行时取 ≤英雄等级 的最大档）
     [SkillTriggerType.Atking]?: TriggerGrouped; // 普通攻击后触发的技能配置，s_uuid: 技能id, t_num: 触发所需的普攻次数
     [SkillTriggerType.Atked]?: TriggerGrouped;  // 受击后触发的技能配置，s_uuid: 技能id, t_num: 触发所需的受击次数
-    [SkillTriggerType.Revive]?: LvReviveEntry[]; // 复活技能配置（按 lv 升序，运行时取 ≤英雄等级 的最大档）
     dis?: number;         // 攻击距离（像素）
     speed?: number;       // 移动速度（像素/秒）
     skills: Record<number, HSkillInfo>;    // 携带技能ID列表
@@ -431,20 +422,6 @@ export interface LvFieldEntry {
     desc?: string;
 }
 
-/**
- * 复活技能按等级解锁：运行时取 ≤英雄等级 的最大 lv 档。
- * name 为该复活技能在英雄语境下的对外展示名（写在第 1 档），缺省回退固定称谓"凤凰涅槃"。
- */
-export interface LvReviveEntry {
-    lv: number;
-    s_uuid: number;
-    r_num: number;
-    upr: number;
-    name?: string;   // 英雄语境对外展示名（写在第 1 档）
-    /** 档位描述（可选，缺省由 HeroSkillText 自动生成） */
-    desc?: string;
-}
-
 /**
  * 额外属性加成按等级叠加：运行时累加所有 ≤英雄等级 的档位。
  */
@@ -908,16 +885,6 @@ export function resolveFieldByLv(field: LvFieldEntry[] | undefined, lv: number):
     return pick ? pick.uuids : [];
 }
 
-/** 解析复活技能在目标等级下的有效配置（取 ≤lv 的最大档） */
-export function resolveReviveByLv(revive: LvReviveEntry[] | undefined, lv: number): { s_uuid: number; r_num: number; upr: number } | undefined {
-    if (!revive || revive.length === 0) return undefined;
-    let pick: LvReviveEntry | undefined;
-    for (const e of revive) {
-        if (e.lv <= lv && (!pick || e.lv > pick.lv)) pick = e;
-    }
-    return pick ? { s_uuid: pick.s_uuid, r_num: pick.r_num, upr: pick.upr } : undefined;
-}
-
 /** 计算目标等级下额外属性加成（hp/ap/def_bonus 一次性奖励 + 成长类型每级递增） */
 function getEvolveBonuses(hero: heroInfo, targetLv: number): { hp: number, ap: number, def: number } {
     const lv = Math.max(1, targetLv);
@@ -1020,6 +987,23 @@ function getWaveCount(seconds: number): number {
     return seconds / HERO_POWER_WEIGHTS.WAVE_DURATION;
 }
 
+/**
+ * 从 dead 触发配置中解析最大复活次数（revive_count）。
+ * 遍历所有 dead 技能的 overrides，取 revive_count 最大值。
+ * @param dead 死亡触发配置
+ * @param lv 英雄等级
+ * @returns 最大复活次数，无复活配置时返回 0
+ */
+export function resolveMaxReviveCount(dead: TriggerGrouped | undefined, lv: number): number {
+    const triggers = resolveTriggerByLv(dead, lv);
+    let maxRevive = 0;
+    for (const t of triggers) {
+        const count = t.overrides?.revive_count ?? 0;
+        if (count > maxRevive) maxRevive = count;
+    }
+    return maxRevive;
+}
+
 /** 计算触发技在目标时间窗内的触发次数 */
 function getTriggerCount(
     type: SkillTriggerType,
@@ -1035,7 +1019,9 @@ function getTriggerCount(
         case SkillTriggerType.FStart:
             return getWaveCount(seconds);
         case SkillTriggerType.Dead:
-            return getWaveCount(seconds) * (1 + (resolveReviveByLv(hero.revive, FightSet.HERO_MAX_LV)?.r_num || 0));
+            // 死亡触发次数 = 回合数 × (1 + 最大复活次数)，复活从 dead 配置中提取
+            const maxRevive = resolveMaxReviveCount(hero.dead, FightSet.HERO_MAX_LV);
+            return getWaveCount(seconds) * (1 + maxRevive);
     }
     return 1;
 }
@@ -1316,9 +1302,14 @@ export function calcHeroPowerDetailed(hero: heroInfo, targetLv: number = 1, seco
     const field = fieldEntries.length > 0 ? calcFieldPowerDetailed(fieldEntries, hero, targetLv, seconds) : { total: 0, items: [] as FieldSkillEval[] };
 
     let reviveValue = 0;
-    const revive = resolveReviveByLv(hero.revive, targetLv);
+    // 复活价值从 dead 触发配置中提取（revive_hp / revive_count）
-    if (revive) {
+    const deadTriggers = resolveTriggerByLv(hero.dead, targetLv);
-        reviveValue = hpEff * revive.upr * revive.r_num * weights.W_revive * getWaveCount(seconds);
+    for (const t of deadTriggers) {
+        const reviveHp = t.overrides?.revive_hp;
+        const reviveCount = t.overrides?.revive_count ?? 0;
+        if (reviveHp !== undefined && reviveCount > 0) {
+            reviveValue = hpEff * (reviveHp / 100) * reviveCount * weights.W_revive * getWaveCount(seconds);
+        }
     }
 
     const total = hpValue + dpsValue + atking.total + atked.total + fstart.total + dead.total + field.total + reviveValue;

assets/script/game/common/config/英雄设计指引.md

@@ -22,6 +22,8 @@
 > - **support / mage → 远程**（普攻 6009\~6012，大招 6200 / 6201 / 6202\~6204）
 >
 > 辅助技能（6301 护盾 / 6302 治疗 / 6412 防御强化 / 6501 复活）不受形态约束，任意形态可用；作大招（skills[1]）时同样按 lv1/lv9/lv16 走 `lv_entries` 分档强化。
+
+**复活机制说明**：复活已纳入 `dead` 触发组，通过 `overrides.revive_hp`（复活回血比例）和 `overrides.revive_count`（复活次数上限）配置，不再使用独立的 `revive` 字段。复活技能仍使用 6501 底座，但数值通过 `overrides` 注入。
 ## 说明模板
 
 ```
@@ -40,18 +42,18 @@ skill[1]_lv16：大招终段强化档（lv_entries）
 atking[0]_lv4：攻击触发（t_num 模拟概率，1=每次 3≈33% 4≈25%）
 atked[0]_lv4：无
 fstart[0]_lv4：无
-dead[0]_lv4：无
+dead[0]_lv1：死亡触发（可含复活效果：overrides.revive_hp / revive_count）
+dead[0]_lv8：死亡触发强化档
+dead[0]_lv16：死亡触发终段档
 field[0]_lv4：驻场光环（无品质门槛，所有英雄均可配置）
-revive[0]_lv1：无（与 skills[1] 互斥二选一；配置时与大招同走 lv1/lv8/lv16 三档）
-revive[0]_lv8：无
-revive[0]_lv16：无
 简化说明：原作缺失机制的替代方案（如有）
 ```
 
 **通用约束**：
 
 - 等级节奏：lv1 激活 skills[0]/skills[1]；lv2 解锁 skills[0] 普攻强化档（`lv_entries` 覆写 ap/弹道/附加效果）；lv4 解锁 atking/atked/fstart/dead/field 触发技能（触发类技能统一 lv4 激活，各触发槽最多 1 个，无品质门槛）；大招（skills[1]）lv9/lv16 走 `lv_entries` 分档提升；lv12 按职业对单项基础属性 +50%（基数取 lv11 当前等级有效值：坦克→def、战士/辅助→hp、刺客/射手/法师→ap）
-- **revive 与大招互斥**：`revive[0]` 与 `skills[1]` 只能二选一；配置 revive 的英雄不走大招体系，revive 采用与大招相同的 3 级成长机制（lv1/lv8/lv16 走 `lv_entries` 分档强化）
+- **dead 触发档位**：死亡触发技能（含复活）按 lv1/lv8/lv16 三档配置，与普通触发技统一节奏；`t_num` 固定为 1（只要死亡就触发）
+- **复活配置规则**：复活效果通过 `dead[s_uuid]` 的 `overrides.revive_hp`（回血比例 %）+ `overrides.revive_count`（次数上限）注入；`s_uuid` 通常使用 6501（复活底座），也可与其他 dead 技能（如 6302 治疗）合并配置，实现"死亡时先触发技能效果、再判定复活"
 - **品质（rarity）仅影响 lv1 初始基础属性**：相邻品质 AP/HP/DEF 相差 5%（系数 1+0.05×(rarity-1)），不再决定 uuid 段位、光环/技能解锁、属性补偿等任何机制；其余配置参数完全一致
 - 能力只能从能力池（BuffList 7001\~7024 / FieldSkillSet 7001\~7020 / SkillSet 底座）引用 + `overrides` 数值覆盖，**禁止新增同义底座**
 
@@ -81,7 +83,7 @@ revive[0]_lv16：无
 - [ ] `timed_buff_id` 指向 BuffList 已存在条目（能力池 2.1/2.2 内）
 - [ ] debuff/buff 只通过 `overrides` 注入，未改动 SkillSet/BuffList 底座
 - [ ] `atking`/`atked`/`fstart`/`dead`/`field` 按 s\_uuid 分组、按 lv 升序，触发类技能统一 lv4 激活（无品质门槛，field 光环任意品质可配）
-- [ ] `revive[0]` 与 `skills[1]` 二选一（互斥）；配置 revive 时按 lv1/lv8/lv16 走 `lv_entries` 3 级成长，与大招同机制
+- [ ] 复活配置在 `dead` 触发组中，使用 `overrides.revive_hp`（回血比例 %）+ `overrides.revive_count`（次数上限），不再使用独立 `revive` 字段
 - [ ] lv12：按职业注入单项属性 +50%（坦克 def、战士/辅助 hp、刺客/射手/法师 ap），基数取 lv11 有效值
 - [ ] 品质（rarity）仅影响 lv1 初始 AP/HP/DEF（相邻差 5%，运行时品质系数统一乘，配置保持裸值），不影响 uuid 段位/光环/技能解锁/属性补偿
 - [ ] `t_num` 概率模拟符合预期（1=每次，3≈33%，4≈25%）

assets/script/game/hero/Hero.ts

@@ -5,7 +5,7 @@ import { smc } from "../common/SingletonModuleComp";
 import { HeroAttrsComp } from "./HeroAttrsComp";
 import { HeroViewComp } from "./HeroViewComp";
 import { BoxSet, FacSet, FightSet, IndexSet } from "../common/config/GameSet";
-import { HeroInfo, resolveFormationTargetX, resolveTriggerByLv, resolveFieldByLv, resolveReviveByLv, resolveSkillOverrides, calcGrowBonus, HeroDisVal, getHeroQualityCoef, getEffectiveStats, HERO_LV12_SPECIAL_LV, HERO_LV12_BASE_LV, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
+import { HeroInfo, resolveFormationTargetX, resolveTriggerByLv, resolveFieldByLv, resolveSkillOverrides, calcGrowBonus, HeroDisVal, getHeroQualityCoef, getEffectiveStats, HERO_LV12_SPECIAL_LV, HERO_LV12_BASE_LV, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
 import { GameEvent } from "../common/config/GameEvent";
 import { SkillTriggerType, HType } from "../common/config/heroSet";
 import { SkillTriggerHelper } from "./SkillTriggerHelper";
@@ -137,7 +137,6 @@ export class Hero extends ecs.Entity {
         model.atking = hero.atking;
         model.atked = hero.atked;
         model.field = hero.field;
-        model.revive = hero.revive;
         model.ap_bonus = hero.ap_bonus;
         model.hp_bonus = hero.hp_bonus;
         model.def_bonus = hero.def_bonus;
@@ -173,14 +172,14 @@ export class Hero extends ecs.Entity {
             model.skills[skill.uuid] = { ...skill, lv: Math.min(FightSet.HERO_SKILL_MAX_LV, Math.max(0, skill.lv + hero_lv - 2)), ccd: 0, overrides: resolveSkillOverrides(skill, hero_lv) };
         }
 
-        // 按当前英雄等级 resolve 触发技能/光环/复活到运行时缓存，供 SkillTriggerHelper 消费
+        // 按当前英雄等级 resolve 触发技能/光环到运行时缓存，供 SkillTriggerHelper 消费
         model.runtime_call = resolveTriggerByLv(model.call, hero_lv);
         model.runtime_dead = resolveTriggerByLv(model.dead, hero_lv);
         model.runtime_fstart = resolveTriggerByLv(model.fstart, hero_lv);
         model.runtime_atking = resolveTriggerByLv(model.atking, hero_lv);
         model.runtime_atked = resolveTriggerByLv(model.atked, hero_lv);
         model.runtime_field = resolveFieldByLv(model.field, hero_lv);
-        model.runtime_revive = resolveReviveByLv(model.revive, hero_lv);
+        // 复活已纳入 dead 触发组，无需单独解析 revive
 
         // 应用额外属性加成（成长类型每级递增 + hp/ap/def_bonus 一次性奖励累加）
         // 成长增量：仅英雄生效（model.fac 已为 HERO），按 grow_type 递增曲线累计

assets/script/game/hero/HeroAtkSystem.ts

@@ -275,21 +275,26 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpda
             // 先触发死亡技能（如亡语），不管后续是否续命都应触发
             this.triggerDeadSkills(target);
 
-            // 濒死回血（revive 系）：不是真正复活，而是血量归零瞬间消耗 1 次续命次数，
+            // 死亡计数 +1（用于 dead 触发统计）
-            // 按比例回血继续战斗。次数每回合重置（见 MissionComp.healAllHeroes）。
+            TAttrsComp.death_count++;
+
+            // 从 runtime_dead 中提取复活配置（revive_hp / revive_count）
             let canRevive = false;
             let maxReviveCount = 0;
-            let reviveHpPercent = 50; // 默认恢复50%
+            let reviveHpPercent = 0;
-            let reviveSkillConf: any = null; // 提取出来的复活技能配置
+            let reviveSkillConf: any = null;
-            if (TAttrsComp.runtime_revive) {
+            if (TAttrsComp.runtime_dead) {
-                const reviveConf = TAttrsComp.runtime_revive;
+                for (const trig of TAttrsComp.runtime_dead) {
-                maxReviveCount = reviveConf.r_num + Math.floor((TAttrsComp.lv - 1) * reviveConf.upr);
+                    const reviveHp = trig.overrides?.revive_hp;
-                if (TAttrsComp.revived_count < maxReviveCount) {
+                    const reviveCount = trig.overrides?.revive_count ?? 0;
-                    canRevive = true;
+                    if (reviveHp !== undefined && reviveCount > 0) {
-                    // 从配置表中读取对应的复活技能配置，ap 字段代表恢复生命值的百分比
+                        maxReviveCount = reviveCount;
-                    reviveSkillConf = SkillSet[reviveConf.s_uuid];
+                        if (TAttrsComp.revived_count < maxReviveCount) {
-                    if (reviveSkillConf && reviveSkillConf.ap) {
+                            canRevive = true;
-                        reviveHpPercent = reviveSkillConf.ap;
+                            reviveHpPercent = reviveHp;
+                            reviveSkillConf = SkillSet[trig.s_uuid];
+                        }
+                        break; // 只取第一个复活配置
                     }
                 }
             }
@@ -297,7 +302,7 @@ export class HeroAtkSystem extends ecs.ComblockSystem implements ecs.ISystemUpda
             if (canRevive) {
                 TAttrsComp.revived_count++;
                 TAttrsComp.is_reviving = true; // 标记为正在复活
-                // 根据技能配置恢复生命值
+                // 根据 dead 触发配置恢复生命值
                 TAttrsComp.hp = Math.floor(TAttrsComp.hp_max * (reviveHpPercent / 100));
                 TAttrsComp.dirty_hp = true;
 

assets/script/game/hero/HeroAttrsComp.ts

@@ -1,5 +1,5 @@
 import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
-import { HeroDisVal, HeroInfo, HSkillInfo, HType, SkillTriggerType, TriggerGrouped, LvFieldEntry, LvReviveEntry, LvBonusEntry, FieldEntry, HRole } from "../common/config/heroSet";
+import { HeroDisVal, HeroInfo, HSkillInfo, HType, SkillTriggerType, TriggerGrouped, LvFieldEntry, LvBonusEntry, FieldEntry, HRole } from "../common/config/heroSet";
 import { mLogger } from "../common/Logger";
 import { FacSet, FightSet } from "../common/config/GameSet";
 import { FieldSkillSet, FieldSkillType, SkillOverrides } from "../common/config/SkillSet";
@@ -53,7 +53,6 @@ export class HeroAttrsComp extends ecs.Comp {
     [SkillTriggerType.Atked]?: TriggerGrouped;
     /** 驻场光环（按 lv 解锁，存活期间全局生效） */
     [SkillTriggerType.Field]?: LvFieldEntry[];
-    [SkillTriggerType.Revive]?: LvReviveEntry[];
     /** 额外攻击/生命/防御加成（按 lv 累加） */
     ap_bonus?: LvBonusEntry[];
     hp_bonus?: LvBonusEntry[];
@@ -72,8 +71,6 @@ export class HeroAttrsComp extends ecs.Comp {
     runtime_fstart?: { s_uuid: number; t_num: number; overrides?: SkillOverrides }[];
     /** 当前等级下生效的驻场光环词条列表 */
     runtime_field?: FieldEntry[];
-    /** 当前等级下生效的复活配置 */
-    runtime_revive?: { s_uuid: number; r_num: number; upr: number };
 
     // ==================== 特殊属性 ====================
     critical: number = 0;       // 暴击率
@@ -95,7 +92,8 @@ export class HeroAttrsComp extends ecs.Comp {
     heal_power: number = 0;         // 治疗强化（百分点；放大该英雄施放技能的治疗量，辅助专精天赋写入）
     buff_power: number = 0;         // buff 强化（百分点；放大该英雄施加的友方 buff 数值，辅助专精天赋写入）
 
-    revived_count: number = 0;  // 已复活次数
+    revived_count: number = 0;  // 已复活次数（从 dead 触发配置的 revive_count 限制）
+    death_count: number = 0;    // 本回合死亡次数（用于 dead 触发统计）
     invincible_time: number = 0;// 无敌时间
 
 
@@ -631,7 +629,6 @@ export class HeroAttrsComp extends ecs.Comp {
         this.atking = undefined;
         this.atked = undefined;
         this.field = undefined;
-        this.revive = undefined;
         this.ap_bonus = undefined;
         this.hp_bonus = undefined;
         this.def_bonus = undefined;
@@ -641,7 +638,6 @@ export class HeroAttrsComp extends ecs.Comp {
         this.runtime_dead = undefined;
         this.runtime_fstart = undefined;
         this.runtime_field = undefined;
-        this.runtime_revive = undefined;
         this.critical = 0;
         this.critical_res = 0;
         this.freeze_chance = 0;
@@ -654,6 +650,7 @@ export class HeroAttrsComp extends ecs.Comp {
         this.knockback_res = 0;
         this.critical_damage = 0;
         this.revived_count = 0;
+        this.death_count = 0;
         this.invincible_time = 0;
         this.puncture_chance = 0;
         this.puncture_dmg_bonus = 0;

assets/script/game/hero/Mon.ts

@@ -3,7 +3,7 @@ import { oops } from "../../../../extensions/oops-plugin-framework/assets/core/O
 import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ecs/ECS";
 import { smc } from "../common/SingletonModuleComp";
 import { BoxSet, FacSet, FightSet, IndexSet } from "../common/config/GameSet";
-import { HeroInfo, resolveTriggerByLv, resolveReviveByLv, resolveSkillOverrides, HeroDisVal, getHeroQualityCoef, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
+import { HeroInfo, resolveTriggerByLv, resolveSkillOverrides, HeroDisVal, getHeroQualityCoef, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
 import { HeroAttrsComp } from "./HeroAttrsComp";
 import { HeroViewComp } from "./HeroViewComp";
 import { MoveComp } from "./MoveComp";
@@ -199,7 +199,6 @@ export class Monster extends ecs.Entity {
         model.fstart = hero.fstart;
         model.atking = hero.atking;
         model.atked = hero.atked;
-        model.revive = hero.revive;
 
         // 标记是否 Boss，非 Boss 默认记作杂兵
         model.is_boss = is_boss
@@ -236,16 +235,15 @@ export class Monster extends ecs.Entity {
             if (testSkills.dead !== undefined) model.dead = testSkills.dead;
             if (testSkills.fstart !== undefined) model.fstart = testSkills.fstart;
             if (testSkills.call !== undefined) model.call = testSkills.call;
-            if (testSkills.revive !== undefined) model.revive = testSkills.revive;
         }
 
-        // 按怪物等级 resolve 触发技能/复活到运行时缓存（怪物无 lv 成长，恒用 mon_lv）
+        // 按怪物等级 resolve 触发技能到运行时缓存（怪物无 lv 成长，恒用 mon_lv）
         model.runtime_call = resolveTriggerByLv(model.call, mon_lv);
         model.runtime_dead = resolveTriggerByLv(model.dead, mon_lv);
         model.runtime_fstart = resolveTriggerByLv(model.fstart, mon_lv);
         model.runtime_atking = resolveTriggerByLv(model.atking, mon_lv);
         model.runtime_atked = resolveTriggerByLv(model.atked, mon_lv);
-        model.runtime_revive = resolveReviveByLv(model.revive, mon_lv);
+        // 复活已纳入 dead 触发组，无需单独解析 revive
 
         // 缓存技能射程等派生数据，减少战斗帧内重复计算
         model.updateSkillDistanceCache();

assets/script/game/map/HerosListComp.ts

@@ -22,7 +22,7 @@ import { ecs } from "../../../../extensions/oops-plugin-framework/assets/libs/ec
 import { CCComp } from "../../../../extensions/oops-plugin-framework/assets/module/common/CCComp";
 import { oops } from "db://oops-framework/core/Oops";
 import { mLogger } from "../common/Logger";
-import { HeroInfo, HeroList, SkillTriggerType, LvFieldEntry, LvReviveEntry, LvTriggerEntry, TriggerGrouped, getHeroDisplayStats } from "../common/config/heroSet";
+import { HeroInfo, HeroList, SkillTriggerType, LvFieldEntry, LvTriggerEntry, TriggerGrouped, getHeroDisplayStats } from "../common/config/heroSet";
 import { buildHeroSkillDesc } from "../common/HeroSkillText";
 import { GameEvent } from "../common/config/GameEvent";
 import { HERO_UPGRADE_NEED_FRAGMENTS, RARITY_BG_COLORS } from "../common/config/GameSet";
@@ -493,7 +493,6 @@ export class HerosListComp extends CCComp {
         SkillTriggerType.Field,
         SkillTriggerType.Atking,
         SkillTriggerType.Atked,
-        SkillTriggerType.Revive,
     ]
 
     /**
@@ -527,8 +526,6 @@ export class HerosListComp extends CCComp {
         for (const type of HerosListComp.PANEL_TRIGGER_TYPES) {
             if (type === SkillTriggerType.Field) {
                 this.addFieldIcons(hero[SkillTriggerType.Field], lv)
-            } else if (type === SkillTriggerType.Revive) {
-                this.addReviveIcon(hero[SkillTriggerType.Revive], lv)
             } else {
                 this.addTriggerIcons(hero[type] as TriggerGrouped | undefined, lv, type)
             }
@@ -584,15 +581,9 @@ export class HerosListComp extends CCComp {
         }
     }
 
-    /** 复活技能：未激活取最低档预览，激活取 ≤lv 最大档 */
+    /** 复活技能已纳入 dead 触发组，通过 dead 配置展示（revive_hp / revive_count） */
-    private addReviveIcon(revive: LvReviveEntry[] | undefined, lv: number) {
+    private addReviveIcon(_revive: unknown, _lv: number) {
-        if (!revive?.length) return
+        // 复活已纳入 dead 触发组，不再单独处理
-        const sorted = [...revive].sort((a, b) => a.lv - b.lv)
-        let active: LvReviveEntry | undefined
-        for (const e of sorted) { if (e.lv <= lv) active = e }
-        const pick = active ?? sorted[0]
-        // 复活档位无 s_lv 概念，技能等级恒为 1（等级标签展示技能等级而非解锁的英雄等级）
-        this.addSkillIcon(pick.s_uuid, 1, !active, false, SkillTriggerType.Revive)
     }
 
     // ======================== 英雄动画 ========================

assets/script/game/map/MissionCardComp.ts

@@ -54,7 +54,7 @@ import { MissSkillsComp } from "./MissSkillsComp";
 import { oops } from "db://oops-framework/core/Oops";
 import { HeroAttrsComp } from "../hero/HeroAttrsComp";
 import { smc } from "../common/SingletonModuleComp";
-import { HeroInfo, HType, resolveTriggerByLv, resolveFieldByLv, resolveReviveByLv, resolveSkillOverrides, calcGrowBonus, getHeroQualityCoef, getEffectiveStats, HERO_LV12_SPECIAL_LV, HERO_LV12_BASE_LV, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
+import { HeroInfo, HType, resolveTriggerByLv, resolveFieldByLv, resolveSkillOverrides, calcGrowBonus, getHeroQualityCoef, getEffectiveStats, HERO_LV12_SPECIAL_LV, HERO_LV12_BASE_LV, HERO_LV12_SPECIAL_ATTR } from "../common/config/heroSet";
 import { applyTalentBonuses } from "../common/config/TalentSet";
 import { HeroViewComp } from "../hero/HeroViewComp";
 import { FacSet, FightSet } from "../common/config/GameSet";
@@ -2223,7 +2223,7 @@ export class MissionCardComp extends CCComp {
         model.runtime_atking = resolveTriggerByLv(model.atking, nextLv);
         model.runtime_atked = resolveTriggerByLv(model.atked, nextLv);
         model.runtime_field = resolveFieldByLv(model.field, nextLv);
-        model.runtime_revive = resolveReviveByLv(model.revive, nextLv);
+        // 复活已纳入 dead 触发组，无需单独解析 revive
 
         model.skills = {};
         for (const key in hero.skills) {

assets/script/game/map/RogueConfig.ts

@@ -22,7 +22,7 @@
  *   手感微调只改 MON_HP_MUL / MON_AP_MUL / BOSS_HP_BONUS_MUL 三个系数即可。
  */
 
-import { HeroInfo, MonType, MonTypeName, TriggerGrouped, LvReviveEntry } from "../common/config/heroSet";
+import { HeroInfo, MonType, MonTypeName, TriggerGrouped } from "../common/config/heroSet";
 import { SkillOverrides } from "../common/config/SkillSet";
 import { FacSet } from "../common/config/GameSet";
 
@@ -200,8 +200,6 @@ export interface MonSkillSet {
     dead?: TriggerGrouped;
     /** 战斗开始触发 */
     fstart?: TriggerGrouped;
-    /** 复活 */
-    revive?: LvReviveEntry[];
     /** 在技能池中的抽取权重 */
     weight: number;
 }
@@ -357,7 +355,6 @@ export interface GeneratedMonster {
         atked?: TriggerGrouped;
         dead?: TriggerGrouped;
         fstart?: TriggerGrouped;
-        revive?: LvReviveEntry[];
     };
 }
 

assets/script/game/map/SSkillBoxComp.ts

@@ -6,7 +6,7 @@ import { CardTriggerType } from "../common/config/CardSet";
 import { SkillSet, FieldSkillSet } from "../common/config/SkillSet";
 import {
     FieldEntry, HeroInfo, TriggerGrouped, SkillTriggerType,
-    getGroupedTriggerName, getFieldSkillName, getReviveSkillName,
+    getGroupedTriggerName, getFieldSkillName,
 } from "../common/config/heroSet";
 import { UIID } from "../common/config/GameUIConfig";
 import { smc } from "../common/SingletonModuleComp";
@@ -136,7 +136,7 @@ export class SSkillBoxComp extends CCComp {
      * 解析技能名称：
      *   1. 显式设置的卡牌名（最高优先级）；
      *   2. 英雄图鉴模式（hero_uuid>0）：从 heroSet 英雄配置解析英雄语境名
-     *      （普攻/大招 HSkillInfo.name、trigger 组名、光环 FieldEntry.name、复活 LvReviveEntry.name）；
+     *      （普攻/大招 HSkillInfo.name、trigger 组名、光环 FieldEntry.name、复活走 dead 组名）；
      *   3. 回退 SkillSet / FieldSkillSet 底座名。
      */
     private resolveSkillName(): string {
@@ -170,14 +170,12 @@ export class SSkillBoxComp extends CCComp {
     private resolveHeroSkillName(): string {
         const hero = HeroInfo[this.hero_uuid];
         if (!hero) return "";
-        // 槽位指定：光环/复活/触发组各自取值，未命中直接回退
+        // 槽位指定：光环/触发组各自取值，未命中直接回退（复活已纳入 dead）
         if (this.hero_slot !== undefined) {
             if (this.hero_slot === SkillTriggerType.Field) {
                 return getFieldSkillName(hero, this.s_uuid);
             }
-            if (this.hero_slot === SkillTriggerType.Revive) {
+            // 复活走 dead 槽位
-                return getReviveSkillName(hero, this.s_uuid);
-            }
             const grouped = hero[this.hero_slot] as TriggerGrouped | undefined;
             if (grouped?.[this.s_uuid]?.length) return getGroupedTriggerName(grouped, this.s_uuid);
             return "";
@@ -194,10 +192,7 @@ export class SSkillBoxComp extends CCComp {
         if (hero.field?.some(e => e.uuids.some(u => u.uuid === this.s_uuid))) {
             return getFieldSkillName(hero, this.s_uuid);
         }
-        // 复活技能
+        // 复活已纳入 dead 触发组，上方 dead 循环已覆盖
-        if (hero.revive?.some(e => e.s_uuid === this.s_uuid)) {
-            return getReviveSkillName(hero, this.s_uuid);
-        }
         return "";
     }