125 战斗 战斗代码整理 修复卡死问题

yyl

2026-04-22 b8f554f03a6114db353736741eda63bdd6c63854

125 战斗 战斗代码整理 修复卡死问题

 Main/System/Battle/BattleDebug.cs

@@ -3,12 +3,52 @@

public static class BattleDebug
{
#if UNITY_EDITOR
    // 每次 Editor 进入 PlayMode 会重置这个 static，初次调用时清空旧文件
    private static bool _logFileInitialized = false;
    private static string _logFilePath;

    private static void EnsureLogFile()
    {
        if (_logFileInitialized) return;
        _logFileInitialized = true;
        try
        {
            string dir = Application.dataPath + "/../BattleReport";
            if (!System.IO.Directory.Exists(dir))
                System.IO.Directory.CreateDirectory(dir);
            _logFilePath = dir + "/BattleDebug.log";
            // 每次启动 PlayMode 清空文件，避免跨次污染
            System.IO.File.WriteAllText(_logFilePath, $"=== BattleDebug log opened at {System.DateTime.Now:HH:mm:ss.fff} ===\n");
        }
        catch (System.Exception e)
        {
            Debug.LogWarning("BattleDebug 打开日志文件失败：" + e.Message);
            _logFilePath = null;
        }
    }

    private static void WriteToFile(string line)
    {
        EnsureLogFile();
        if (string.IsNullOrEmpty(_logFilePath)) return;
        try
        {
            System.IO.File.AppendAllText(_logFilePath,
                $"[{Time.frameCount} {Time.realtimeSinceStartup:F3}] " + line + "\n");
        }
        catch { /* 忽略文件写入异常，别影响逻辑 */ }
    }
#endif

    public static void LogError(string _logMessage)
    {
#if UNITY_EDITOR
        if (Launch.Instance.isOpenBattleDebug)
        if (Launch.Instance != null && Launch.Instance.isOpenBattleDebug)
        {
            Debug.LogWarning("BattleLog: " + _logMessage);
            if (Launch.Instance.isOpenBattleDebugLogFile)
                WriteToFile(_logMessage);
        }
#endif
    }

 Main/System/Battle/BattleField/BattleField.cs

@@ -107,6 +107,21 @@

        if (castingSkillDict.TryGetValue(objID, out skillBases))
        {
#if UNITY_EDITOR
            //  诊断：同一个 caster 已经在 casting，说明前一个技能没正确 Remove。
            //  打印现存技能的 skillId / StateFlags，方便定位泄漏点。
            var sb = new System.Text.StringBuilder();
            sb.Append("BattleField.AddCastingSkill 发现同 caster 已有 ").Append(skillBases.Count).Append(" 个 casting 技能未清理：objID=").Append(objID);
            sb.Append("  新入=skillId=").Append(skill?.skillConfig?.SkillID ?? 0);
            for (int i = 0; i < skillBases.Count; i++)
            {
                var s = skillBases[i];
                sb.Append("\n    [").Append(i).Append("] skillId=")
                  .Append(s?.skillConfig?.SkillID ?? 0)
                  .Append(" StateFlags=").Append(s == null ? "null" : s.StateFlagsForDebug.ToString());
            }
            BattleDebug.LogError(sb.ToString());
#endif
            skillBases.Add(skill);
        }
        else
@@ -123,6 +138,13 @@

        if (castingSkillDict.TryGetValue(objID, out skillBases))
        {
#if UNITY_EDITOR
            bool existed = skillBases.Contains(skillBase);
            if (!existed)
            {
                BattleDebug.LogError($"BattleField.RemoveCastingSkill 目标不在 casting 列表：objID={objID} skillId={skillBase?.skillConfig?.SkillID ?? 0}");
            }
#endif
            skillBases.Remove(skillBase);

            if (skillBases.Count == 0)
@@ -130,6 +152,12 @@
                castingSkillDict.Remove(objID);
            }
        }
#if UNITY_EDITOR
        else
        {
            BattleDebug.LogError($"BattleField.RemoveCastingSkill objID 不在字典里：objID={objID} skillId={skillBase?.skillConfig?.SkillID ?? 0}");
        }
#endif
    }

    public bool IsCastingSkill(long objID)

 Main/System/Battle/BattleObject/HeroBattleObject.cs

@@ -186,9 +186,9 @@
        }
    }
    
    public override Spine.TrackEntry PlaySkillAnimation(SkillConfig skillConfig, SkillSkinConfig skillSkinConfig, SkillBase skillBase, bool isCounter, Action onComplete)
    public override Spine.TrackEntry PlaySkillAnimation(SkillConfig skillConfig, SkillSkinConfig skillSkinConfig, SkillBase skillBase, bool isSubSkill, Action onComplete)
    {
        return motionBase.PlaySkillAnimation(skillConfig, skillSkinConfig, skillBase, isCounter, onComplete);
        return motionBase.PlaySkillAnimation(skillConfig, skillSkinConfig, skillBase, isSubSkill, onComplete);
    }
    
    public override bool CanStartDeath()

 Main/System/Battle/Motion/MotionBase.cs

@@ -34,11 +34,35 @@
    // 子技能轨道池管理（在Init中初始化，不要在这里初始化）
    private Queue<int> availableSubTracks;
    private Dictionary<SkillBase, int> subSkillTrackMap = new Dictionary<SkillBase, int>();

    //  记录"当前所有仍在本 MotionBase 上运行的 skillBase"，不区分主/子技能。
    //  作用：HaveRest / ResetForReborn 这类粗暴清字典的调用在清之前必须强制结束这些 skillBase，
    //  否则它们的 frameHandler 被删、活跃 track 被清，但 skillBase.IsFinished() 永远 false，
    //  上层 RecordPlayer 就永远等不到它结束。
    private HashSet<SkillBase> activeSkillBases = new HashSet<SkillBase>();
    
    private SkeletonIllusionShadow illusionShadow;
    private bool playingSkill = false;

    private bool playingSkillWithAnim = false;
    private bool _playingSkillWithAnim = false;
    private bool playingSkillWithAnim
    {
        get => _playingSkillWithAnim;
        set
        {
#if UNITY_EDITOR
            if (_playingSkillWithAnim != value
                && Launch.Instance != null && Launch.Instance.isOpenBattleDebug)
            {
                string owner = skeletonAnim != null && skeletonAnim.gameObject != null ? skeletonAnim.gameObject.name : "(no-skel)";
                // 每次变更打印栈，定位到底是谁把 playingSkillWithAnim 设 true 了、谁清/不清
                BattleDebug.LogError($"[MotionBase owner={owner} hash={GetHashCode()}] playingSkillWithAnim {_playingSkillWithAnim} -> {value}\n"
                    + UnityEngine.StackTraceUtility.ExtractStackTrace());
            }
#endif
            _playingSkillWithAnim = value;
        }
    }

    private bool isUnderControl = false;

@@ -151,6 +175,38 @@

    private void AddAction(Action action) => runningActions.Add(action);
    private void RemoveAction(Action action) => runningActions.Remove(action);

    //  在 ExecuteSkillAnim 的各条退出路径统一调用，保证 activeSkillBases 与 runningActions 同步。
    private void RemoveSkillAnim(Action frameHandler, SkillBase skillBase)
    {
        RemoveAction(frameHandler);
        if (skillBase != null) activeSkillBases.Remove(skillBase);
    }

#if UNITY_EDITOR
    // 诊断用：导出活跃技能轨道 + Spine 动画状态 + 挂起的 frameHandler 数量
    public string DumpActiveTracksForDebug()
    {
        var sb = new System.Text.StringBuilder();
        string owner = skeletonAnim != null && skeletonAnim.gameObject != null ? skeletonAnim.gameObject.name : "(no-skel)";
        sb.Append($"[hash={GetHashCode()} owner={owner}] playingSkill={playingSkill} playingSkillWithAnim={playingSkillWithAnim} runningActions.Count={runningActions.Count} activeSkillTracks.Count={activeSkillTracks.Count}");
        if (isUnderControl) sb.Append(" [UnderControl]");
        if (skeletonAnim != null) sb.Append($" timeScale={skeletonAnim.timeScale}");
        foreach (var kv in activeSkillTracks)
        {
            var track = kv.Value;
            if (track == null)
            {
                sb.Append($"\n    track[{kv.Key}]=null");
                continue;
            }
            string animName = track.Animation != null ? track.Animation.Name : "(null)";
            float duration = track.Animation != null ? track.Animation.Duration : -1f;
            sb.Append($"\n    track[{kv.Key}] anim={animName} TrackTime={track.TrackTime:F3} duration={duration:F3} isComplete={track.IsComplete} timeScale={track.TimeScale}");
        }
        return sb.ToString();
    }
#endif
    
    // 检查是否有活跃的技能轨道（排除死亡轨道）
    private bool HasActiveSkillTracks()
@@ -293,6 +349,9 @@
        // startTime 表示技能"本地逻辑时间"的起点（以 Time.time 为基准）
        float startTime = hasAnim ? 0f : Time.time;

        //  登记到活跃集合，让 HaveRest / ResetForReborn 知道有哪些 skillBase 需要在清字典前被强制结束。
        activeSkillBases.Add(skillBase);

        skillBase.OnSkillStart();

        Action frameHandler = null;
@@ -326,7 +385,7 @@

                
                
                RemoveAction(frameHandler);
                RemoveSkillAnim(frameHandler, skillBase);
                return;
            }

@@ -360,7 +419,7 @@
                    skillBase.ForceFinished();

                    // 清理并确保状态复位
                    RemoveAction(frameHandler);
                    RemoveSkillAnim(frameHandler, skillBase);
                    
                    // 回收子技能轨道
                    if (isSubSkill && subSkillTrackMap.ContainsKey(skillBase))
@@ -383,7 +442,7 @@
                {
                    Debug.LogError("技能动画播放失败，强制结束 " + skillConfig.SkillID + " is caster dead " + skillBase.caster.IsDead());
                    skillBase.ForceFinished();
                    RemoveAction(frameHandler);
                    RemoveSkillAnim(frameHandler, skillBase);
                    if (activeSkillTracks.ContainsKey(trackIndex))
                        activeSkillTracks.Remove(trackIndex);
                    
@@ -498,7 +557,7 @@

                    // skillTrackDict.Remove(trackIndex);

                    RemoveAction(frameHandler);
                    RemoveSkillAnim(frameHandler, skillBase);
                    onComplete?.Invoke();
                    skillBase.OnFinalFrameEnd();
                    if (hasAnim)
@@ -647,6 +706,16 @@
    // 原有的 HaveRest 保持不变，用于一般的重置
    public void HaveRest()
    {
#if UNITY_EDITOR
        if (Launch.Instance != null && Launch.Instance.isOpenBattleDebug)
        {
            string owner = skeletonAnim != null && skeletonAnim.gameObject != null ? skeletonAnim.gameObject.name : "(no-skel)";
            BattleDebug.LogError($"[MotionBase.HaveRest owner={owner} hash={GetHashCode()}] 调用栈：\n{UnityEngine.StackTraceUtility.ExtractStackTrace()}");
        }
#endif
        // 先强制结束所有正在运行的 skillBase，避免清字典后这些 skillBase 的 frameHandler 被删但自身 StateFlags 永远停在 Started
        ForceFinishRunningSkillBases();

        animState?.ClearTracks();

        trackEntryCallbacks.Clear();
@@ -668,14 +737,42 @@

        currentTrack = null;

        
        playingSkill = false;
        playingSkillWithAnim = false;
        PlayAnimation(MotionName.idle, true);
    }

    // HaveRest / ResetForReborn 这类“粗暴清理”调用会直接 Clear runningActions/activeSkillTracks，
    // 导致跟这些轨道绑定的 skillBase 永远收不到 OnFinalFrameEnd，威胁上层 RecordPlayer。
    // 这里遍历 activeSkillBases（主/子技能都覆盖），逐个 ForceFinished，然后清空集合。
    private void ForceFinishRunningSkillBases()
    {
        if (activeSkillBases.Count == 0)
            return;
        var snapshot = new List<SkillBase>(activeSkillBases);
        activeSkillBases.Clear();
        foreach (var sb in snapshot)
        {
            if (sb != null && !sb.IsFinished())
                sb.ForceFinished();
        }
    }

    // 新增：专门用于复活的完整重置方法
    public void ResetForReborn(bool reviveSelf = false)
    {
#if UNITY_EDITOR
        if (Launch.Instance != null && Launch.Instance.isOpenBattleDebug)
        {
            string owner = skeletonAnim != null && skeletonAnim.gameObject != null ? skeletonAnim.gameObject.name : "(no-skel)";
            BattleDebug.LogError($"[MotionBase.ResetForReborn owner={owner} hash={GetHashCode()}] reviveSelf={reviveSelf} 调用栈：\n{UnityEngine.StackTraceUtility.ExtractStackTrace()}");
        }
#endif
        // 跟 HaveRest 同理：先强制结束所有正在运行的 skillBase，
        // 避免下面清 runningActions / activeSkillTracks 后它们永远接收不到帧回调。
        if (!reviveSelf)
            ForceFinishRunningSkillBases();

        // 1. 清理所有动画轨道（包括死亡动画的轨道9）
        animState?.ClearTracks();

@@ -706,6 +803,10 @@
        
        // 5. 重置所有状态标志
        playingSkill = false;
        //  reviveSelf 分支下 runningActions 没被清，主技能 frameHandler 会自己走到 OnFinalFrameEnd 那里复位；
        //  非 reviveSelf 分支下 runningActions 已清干净，这里一并复位。
        if (!reviveSelf)
            playingSkillWithAnim = false;
        isUnderControl = false;
        
        // 6. 重置时间相关字段（关键！）
@@ -753,6 +854,11 @@
        return !playingSkillWithAnim || string.IsNullOrEmpty(skillSkinConfig.SkillMotionName);
    }

#if UNITY_EDITOR
    /// <summary>卡死诊断用：暴露 playingSkillWithAnim 标志位。</summary>
    public bool PlayingSkillWithAnimForDebug => playingSkillWithAnim;
#endif

    public bool CanStartDeath()
    {
        return !playingSkillWithAnim;

 Main/System/Battle/RecordPlayer/RecordPlayer.cs

@@ -45,6 +45,93 @@
        return isPlaying;
    }

#if UNITY_EDITOR
    /// <summary>
    /// 卡死排查用：dump 出当前 RecordPlayer 内部所有在播 / 排队 / 即时播放 的 RecordAction 概要。
    /// </summary>
    public string DumpPlayingState()
    {
        return DumpPlayingState(0);
    }

    //  depth 用于控制递归深度，最多展开两层嵌套（父 inner player -> 子 SkillRecordAction -> 孙 inner player）
    public string DumpPlayingState(int depth)
    {
        string indent = new string(' ', depth * 4);
        var sb = new System.Text.StringBuilder();
        sb.Append("current=");
        if (currentRecordAction == null)
        {
            sb.Append("null");
        }
        else
        {
            AppendActionBrief(sb, currentRecordAction);
        }

        sb.Append("  queue.Count=").Append(recordActionQueue.Count);
        if (recordActionQueue.Count > 0)
        {
            sb.Append(" [");
            int i = 0;
            foreach (var act in recordActionQueue)
            {
                if (i > 0) sb.Append(", ");
                sb.Append(act.GetType().Name);
                if (++i >= 5) { sb.Append(", ..."); break; }
            }
            sb.Append("]");
        }

        sb.Append("  immediatelyList.Count=").Append(immediatelyActionList.Count);
        if (immediatelyActionList.Count > 0)
        {
            sb.Append(" [");
            for (int i = 0; i < immediatelyActionList.Count && i < 5; i++)
            {
                if (i > 0) sb.Append(", ");
                var act = immediatelyActionList[i];
                if (act == null) { sb.Append("null"); continue; }
                sb.Append(act.GetType().Name)
                  .Append("(IsFin=").Append(act.IsFinished())
                  .Append(",CanStart=").Append(act.CanStartExecution())
                  .Append(",Waiting=").Append(act.isWaitingPlay)
                  .Append(")");
            }
            if (immediatelyActionList.Count > 5) sb.Append(", ...");
            sb.Append("]");
        }

        //  递归展开嵌套 SkillRecordAction 的内部状态（最多 2 层，避免无限递归）
        if (depth < 2)
        {
            if (currentRecordAction is SkillRecordAction sra && sra.skillBase != null)
            {
                sb.Append('\n').Append(indent).Append("  └ [current] skillId=")
                  .Append(sra.skillBase.skillConfig?.SkillID ?? 0)
                  .Append(" caster=").Append(sra.skillBase.tagUseSkillAttack?.ObjID ?? 0UL)
                  .Append(" StateFlags=").Append(sra.skillBase.StateFlagsForDebug);
                //  进一步展开它自己的 inner player
                var innerPlayer = sra.GetInnerRecordPlayer();
                if (innerPlayer != null && innerPlayer.IsPlaying())
                {
                    sb.Append('\n').Append(indent).Append("    innerRecordPlayer: ")
                      .Append(innerPlayer.DumpPlayingState(depth + 1));
                }
            }
        }

        return sb.ToString();
    }

    private static void AppendActionBrief(System.Text.StringBuilder sb, RecordAction act)
    {
        sb.Append(act.GetType().Name)
          .Append(" IsFinished=").Append(act.IsFinished())
          .Append(" IsActionCompleted=").Append(act.IsActionCompleted());
    }
#endif

    public void PlayRecord(RecordAction recordAction)
    {
        if (recordAction == null) return;
@@ -215,6 +302,15 @@
                //  检查是否可以开始执行（WaitingPlay条件检查）
                if (!action.CanStartExecution())
                {
                    //  修复：即便 CanStartExecution 返回 false，只要 action 已经 IsFinished，
                    //  也必须从列表里移除，否则它会永久占位导致 IsPlaying() 一直为 true，
                    //  让父技能卡在 ownRecordAction.innerRecordPlayer.IsPlaying() 的分支上。
                    //  （典型场景：一个 caster 连续释放两个技能，第一个已结束但 caster 仍被
                    //  记为 IsCastingSkill，SkillBase.CanStartExecution 返回 false。）
                    if (action.IsFinished())
                    {
                        removeIndexList.Add(i);
                    }
                    continue;
                }
                

 Main/System/Battle/Skill/SkillBase.Buff.cs

New file
@@ -0,0 +1,65 @@
using System.Collections.Generic;

// SkillBase（Buff 部分）：Buff 包（HB428 刷新 / HB429 删除）的识别与分发。
public partial class SkillBase
{
    /// <summary>
    /// 判断是否为 Buff 相关的包（HB428 或 HB429）
    /// </summary>
    protected bool IsBuffPack(GameNetPackBasic pack)
    {
        return pack is HB428_tagSCBuffRefresh || pack is HB429_tagSCBuffDel;
    }

    /// <summary>
    /// 处理收集到的 Buff 包列表（HB428 刷新 和 HB429 删除）
    /// </summary>
    protected void ProcessBuffPacks(List<GameNetPackBasic> buffPacks)
    {
        if (buffPacks == null || buffPacks.Count == 0) return;

        foreach (var pack in buffPacks)
        {
            if (pack is HB428_tagSCBuffRefresh buffRefresh)
            {
                BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffRefresh.ObjID);
                if (battleObj != null)
                {
                    var buffMgr = battleObj.GetBuffMgr();
                    if (buffMgr != null) // 命格不有 buff 管理器
                    {
                        buffMgr.RefreshBuff(buffRefresh, true);
                    }
                }
            }
            else if (pack is HB429_tagSCBuffDel buffDel)
            {
                BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffDel.ObjID);
                if (battleObj != null)
                {
                    var buffMgr = battleObj.GetBuffMgr();
                    if (buffMgr != null) // 命格不有 buff 管理器
                    {
                        buffMgr.RemoveBuff(buffDel, false);
                    }
                }
            }
        }
    }

    /// <summary>
    /// 强制分发 Buff 包（用于 ForceFinished 场景）
    /// </summary>
    protected void DistributeBuffPacks(List<GameNetPackBasic> buffPacks)
    {
        if (buffPacks == null || buffPacks.Count == 0) return;

        foreach (var pack in buffPacks)
        {
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：Buff包是技能效果的核心组成部分，应该由SkillRecordAction管理
            // 即使是强制分发的情况，也要保持在正确的RecordAction上下文中
            PackageRegeditEx.DistributeToRecordAction(pack, ownRecordAction);
        }
    }
}

 Main/System/Battle/Skill/SkillBase.Buff.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 6a276ba860f155b4ebb6131e4a9d03be
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.Cast.cs

New file
@@ -0,0 +1,366 @@
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Spine;

// SkillBase（Cast 部分）：施法阶段——移动、动画、残影、高亮、攻击结束。
public partial class SkillBase
{
    // 技能释放主逻辑：广播事件、高亮目标、执行释放
    public virtual void Cast()
    {
        // 广播技能释放事件
        string guid = battleField.guid;
        // 获取释放者数据：Hero 传递 teamHero，Mingge 传递 null（因为事件监听器只处理 Hero 数据）
        TeamHero teamHero = null;
        if (caster is HeroBattleObject heroBattleObject)
        {
            teamHero = heroBattleObject.teamHero;
        }
        // 命格释放技能时 teamHero 为 null，监听器会正确处理（已有 null 检查）
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);

        if (skillSkinConfig.SkinllSFX1 != 0)
        {
            battleField.soundManager.PlayEffectSound(skillSkinConfig.SkinllSFX1, false);
        }

        if (caster != null)
        {
            // 战斗类型 0-常规；1-连击；2-反击；3-追击；4-子技能；5-被动触发的
            DamageNumConfig hintConfig = null;
            if (tagUseSkillAttack.BattleType == 1)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleComboAttack);
            }
            else if (tagUseSkillAttack.BattleType == 2)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleCounterAttack);
            }
            else if (tagUseSkillAttack.BattleType == 3)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleChaseAttack);
            }

            Hint(caster, hintConfig);
        }

        // 高亮所有本次技能相关的目标
        HighLightAllTargets();

        // 根据释放模式执行相应逻辑
        switch (skillSkinConfig.castMode)
        {
            case SkillCastMode.None:
            case SkillCastMode.Self:
                CastImpl(OnAttackFinish);
                break;
            case SkillCastMode.Enemy:
                CastToEnemy();
                break;
            case SkillCastMode.Target:
                CastToTarget();
                break;
            case SkillCastMode.Allies:
                CastToAllies();
                break;
            case SkillCastMode.DashCast:
                DashCast(OnAttackFinish);
                break;
            default:
                Debug.LogError("强制结束技能 暂时不支持其他的方式释放 有需求please联系策划 技能id:" + skillConfig.SkillID + " cast position " + skillSkinConfig.CastPosition);
                ForceFinished();
                break;
        }
    }

    protected void Hint(BattleObject battleObject, DamageNumConfig hintConfig)
    {
        if (hintConfig != null)
        {
            battleObject.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
        }
    }

    // 冲撞攻击模式（待实现）
    protected void DashCast(Action _onComplete)
    {
        Debug.LogError("DashCast 还没实现");
        ForceFinished();
    }

    // 对敌方释放技能：移动到敌方区域进行攻击
    protected void CastToEnemy()
    {
        RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillSkinConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            if (skillConfig.ClientTriggerTiming == 1)
            {
                OnAttackFinish();
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.GetPositionNum()), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);
            }
        });
    }

    // 对指定目标释放技能：移动到主要目标位置进行攻击
    protected void CastToTarget()
    {
        if (tagUseSkillAttack.HurtCount <= 0)
        {
            Debug.LogError("技能攻击包没有目标 HurtCount <= 0");
            OnSkillFinished();
            return;
        }

        int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(this, caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
        BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
        RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);

        ExecuteMoveAndCastSequence(targetTrans, () =>
        {
            RectTransform rectTransform = battleField.GetTeamNode(caster.Camp, caster.GetPositionNum());
            // ShadowIllutionCreate(true);
            MoveToTarget(rectTransform, Vector2.zero, () =>
            {
                // ShadowIllutionCreate(false);
                OnAttackFinish();
            }, MoveSpeed);
        });
    }

    // 对友方释放技能：移动到友方区域进行治疗或增益
    protected void CastToAllies()
    {
        RectTransform target = battleField.GetTeamNode(caster.Camp, skillSkinConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            if (skillConfig.ClientTriggerTiming == 1)
            {
                OnAttackFinish();
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.GetPositionNum()), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);
            }
        });
    }

    // 执行移动-施法-返回序列：通用的移动攻击流程
    private void ExecuteMoveAndCastSequence(RectTransform target, Action onReturnComplete)
    {
        ShadowIllutionCreate(true);
        MoveToTarget(target, new Vector2(skillSkinConfig.CastDistance, 0), () =>
        {
            if (skillSkinConfig.CastDistance < 9999 && skillSkinConfig.SkinllSFX2 != 0)
            {
                battleField.soundManager.PlayEffectSound(skillSkinConfig.SkinllSFX2, false);
            }

            TurnBack(() =>
            {
                ShadowIllutionCreate(false);

                CastImpl(() =>
                {
                    TurnBack(() =>
                    {
                        try
                        {
                            onReturnComplete?.Invoke(); // 添加异常处理防止回调异常导致状态不完整
                        }
                        catch (Exception ex)
                        {
                            Debug.LogError($"ExecuteMoveAndCastSequence回调异常: {ex.Message}");
                            throw;
                        }
                    }, -1f);
                });
            }, -1f);
        });
    }

    // 移动到目标位置：处理角色的移动动画和逻辑
    protected void MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 750f)
    {
        if (skillSkinConfig.CastDistance >= 9999)
        {
            _onComplete?.Invoke();
            return;
        }

        caster.PlayAnimation(MotionName.run, true);
        var tweener = BattleUtility.MoveToTarget(caster.GetRectTransform(), target, offset, () =>
        {
            caster.PlayAnimation(MotionName.idle, true);
            _onComplete?.Invoke();
        }, speed);
        battleField.battleTweenMgr.OnPlayTween(tweener);
    }

    // 转身逻辑：根据技能配置处理角色转向
    protected void TurnBack(Action _onComplete, float forward)
    {
        if (skillSkinConfig.CastDistance < 0)
        {
            caster.SetFacing(forward);
        }
        _onComplete?.Invoke();
    }

    // 攻击完成后的处理：转身、恢复状态、播放待机动画
    protected void OnAttackFinish()
    {
        TurnBack(null, 1f);
        OnAllAttackMoveFinished();
        caster.PlayAnimation(MotionName.idle, true);
    }

    // 所有攻击移动完成后的处理：恢复UI显示状态
    protected virtual void OnAllAttackMoveFinished()
    {
        moveFinished = true;
        List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
        foreach (BattleObject bo in allList)
        {
            bo.layerMgr.SetFront();
            bo.GetHeroInfoBar()?.SetActive(true);
        }
        battleField.battleRootNode.skillMaskNode.SetActive(false);
    }

    // 执行技能释放动画和逻辑：播放施法动作并提供回调
    protected TrackEntry CastImpl(Action onComplete = null)
    {
        return caster.PlaySkillAnimation(skillConfig, skillSkinConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
    }

    // 残影效果开关：连击/反击/追击时开启彩色残影并加速
    protected void ShadowIllutionCreate(bool create)
    {
        if (create)
        {
            Color color = Color.white;
            //1-连击；2-反击；3-追击
            //  反击蓝色
            //  追击连击绿色
            bool change = false;
            if (tagUseSkillAttack.BattleType == 1)
            {
                color = colorGreen;
                change = true;
            }
            else if (tagUseSkillAttack.BattleType == 2)
            {
                color = colorBlue;
                change = true;
            }
            else if (tagUseSkillAttack.BattleType == 3)
            {
                color = colorGreen;
                change = true;
            }

            if (change)
            {
                MoveSpeed = 1125f;
                caster.ShowIllusionShadow(true, color);
            }
        }
        else
        {
            MoveSpeed = 750f;
            caster.ShowIllusionShadow(false);
        }
    }

    // 高亮所有相关目标：设置施法者和目标的显示层级
    protected void HighLightAllTargets()
    {
        caster.layerMgr.SetSortingOrder(BattleConst.SkillMaskOrder + 1);// offset是3 英雄层级 +1就是 active级别 

        if (skillConfig.FuncType != 2)
            return;

        // 收集所有目标（包含 HurtList、每个 Hurt 的 HurtListEx、以及顶层 HurtListEx）
        var targetSet = new HashSet<BattleObject>();
        if (tagUseSkillAttack != null)
        {
            // 主目标列表
            if (tagUseSkillAttack.HurtList != null)
            {
                foreach (var hurt in tagUseSkillAttack.HurtList)
                {
                    var bo = battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (bo != null) targetSet.Add(bo);

                    // 主目标的额外目标（弹射/平摊）
                    if (hurt.HurtListEx != null)
                    {
                        foreach (var hurtEx in hurt.HurtListEx)
                        {
                            var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                            if (exBo != null) targetSet.Add(exBo);
                        }
                    }
                }
            }

            // 技能包顶层的 HurtListEx（如溅射、顶层平摊）
            if (tagUseSkillAttack.HurtListEx != null)
            {
                foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
                {
                    var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                    if (exBo != null) targetSet.Add(exBo);
                }
            }
        }

        // 确保施法者也被高亮（原逻辑）
        var highlightList = new List<BattleObject>(targetSet) { caster };

        var allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList();

        // 构造集合便于判断
        var targetSetLookup = new HashSet<BattleObject>(targetSet);
        var highlightSet = new HashSet<BattleObject>(highlightList);

        // 先把施法者的 InfoBar 隐藏（原逻辑保留）
        caster.GetHeroInfoBar()?.SetActive(false);

        foreach (BattleObject bo in allList)
        {
            bool isHighlight = highlightSet.Contains(bo);
            bool isTarget = targetSetLookup.Contains(bo);

            if (isHighlight)
            {
                bo.layerMgr.SetFront();
            }
            else
            {
                bo.layerMgr.SetBack();
            }

            // 目标（含 HurtListEx）都应显示 InfoBar
            bo.GetHeroInfoBar()?.SetActive(isTarget);
        }

        battleField.battleRootNode.skillMaskNode.SetActive(true);
    }
}

 Main/System/Battle/Skill/SkillBase.Cast.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a3bffc7bae40d6e4dbd4f0ee6fd7d6f9
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.Death.cs

New file
@@ -0,0 +1,325 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

// SkillBase（Death 部分）：死亡包、HP 刷新、掉落、经验的收集与分配。
public partial class SkillBase
{
    // 处理HP刷新包（简化逻辑）
    private void HandleRefreshHP()
    {
        // 查找HP刷新包
        HB419_tagSCObjHPRefresh refreshPack = BattleUtility.FindObjHPRefreshPack(packList);

        if (refreshPack != null)
        {
            // 分发HP刷新包
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：HP刷新包是技能内部产生的，应该由当前SkillRecordAction的innerRecordPlayer管理
            // 这样可以确保HP刷新与技能的生命周期绑定，ForceFinish时一并处理
            PackageRegeditEx.DistributeToRecordAction(refreshPack, ownRecordAction);
            packList.Remove(refreshPack);
        }
    }

    // 处理死亡相关逻辑：分配掉落和经验
    protected void HandleDead()
    {
        List<BattleDeadPack> deadPackList = BattleUtility.FindDeadPack(packList);
        if (deadPackList.Count <= 0) return;

        foreach (var deadPack in deadPackList)
        {
            packList.Remove(deadPack.deadPack);
            packList.Remove(deadPack.deadTriggerSkill);
        }

        // 找到最大的死亡包 packUID
        BattleDeadPack lastBattleDeadPack = null;
        ulong maxDeathPackUID = 0;
        foreach (var deadPack in deadPackList)
        {
            if (deadPack.deadPack != null && deadPack.deadPack.packUID > maxDeathPackUID)
            {
                maxDeathPackUID = deadPack.deadPack.packUID;
                lastBattleDeadPack = deadPack;
            }
        }

        // 如果找到了死亡包，收集所有 packUID > maxDeathPackUID 的包
        if (maxDeathPackUID > 0 && lastBattleDeadPack != null)
        {
            BattleDebug.LogError($"SkillBase.HandleDead: 找到死亡包，maxDeathPackUID = {maxDeathPackUID}，开始收集死亡后的包");

            // 1. 收集 packList 中 packUID 大于死亡包的包（排除经验包和掉落包，它们需要在当前技能中处理）
            List<GameNetPackBasic> packsToRemove = new List<GameNetPackBasic>();
            foreach (var pack in packList)
            {
                ulong packUID = GetPackUID(pack);
                if (packUID > maxDeathPackUID)
                {
                    // 排除经验包和掉落包，它们属于当前死亡事件的一部分，不是"死亡后"的包
                    if (pack is HB405_tagMCAddExp expPack && expPack.Source == 2 ||
                        (pack is H0704_tagRolePackRefresh h0704 && h0704.PackType == (byte)PackType.DropItem && h0704.IsBind == 1))
                    {
                        continue; // 跳过经验包和掉落包，让 CheckAfterDeadhPack() 处理它们
                    }

                    BattleDebug.LogError($"SkillBase.HandleDead: 从packList收集死亡后的包 - Type: {pack.GetType().Name}, UID: {packUID}");
                    lastBattleDeadPack.packListAfterDeath.Add(pack);
                    packsToRemove.Add(pack);
                }
            }

            packList.RemoveAll(p => packsToRemove.Contains(p));
        }

        CheckAfterDeadhPack();

        // 修复：先收集要删除的包，避免在foreach中修改集合
        var dropPacksToRemove = new List<H0704_tagRolePackRefresh>(dropPackList);
        foreach (var _dropPack in dropPacksToRemove)
        {
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：掉落包是技能效果的一部分，应该由当前SkillRecordAction管理
            // 掉落包的分发与技能完成绑定，确保在技能ForceFinish时正确处理
            PackageRegeditEx.DistributeToRecordAction(_dropPack, ownRecordAction);
            packList.Remove(_dropPack);
        }

        // 获取并分配掉落物品和经验
        var dropPack = PackManager.Instance.GetSinglePack(PackType.DropItem);
        var itemDict = dropPack.GetAllItems();
        List<ItemModel> itemList = new List<ItemModel>(itemDict.Values.Where(item => item != null && item.isAuction));

        var dropAssign = AssignDrops(itemList, deadPackList.Count);
        var expAssign = AssignExp(expPackList, deadPackList.Count);

        // 构造BattleDrops并缓存
        for (int i = 0; i < deadPackList.Count; i++)
        {
            BattleDeadPack bdp = deadPackList[i];
            int objID = (int)bdp.deadPack.ObjID;
            BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject(objID);

            // 修复：添加空值检查
            if (deadTarget == null)
            {
                Debug.LogError($"找不到死亡目标，ObjID: {objID}");
                continue;
            }

            List<int> itemIndexList = dropAssign[i].Select(item => item.gridIndex).ToList();

            BattleDrops battleDrops = new BattleDrops()
            {
                rectTransform = deadTarget.GetRectTransform(),
                dropItemPackIndex = itemIndexList,
                expDrops = expAssign[i]
            };

            // 修复：避免字典键冲突，使用安全的添加方式
            if (!tempDropList.ContainsKey(objID))
            {
                tempDropList.Add(objID, battleDrops);
            }
            else
            {
                Debug.LogWarning($"tempDropList中已存在ObjID={objID}的记录，将覆盖原值");
                tempDropList[objID] = battleDrops; // 覆盖现有值
            }

            if (!tempDeadPackList.ContainsKey(objID))
            {
                tempDeadPackList.Add(objID, deadPackList[i]);
            }
            else
            {
                Debug.LogWarning($"tempDeadPackList中已存在ObjID={objID}的记录，将覆盖原值");
                tempDeadPackList[objID] = deadPackList[i]; // 覆盖现有值
            }
        }

        // 修复：避免在遍历时修改集合，先收集后删除
        var deadPacksToRemove = new List<GameNetPackBasic>(deadPackList.Select(d => d.deadPack));
        deadPacksToRemove.AddRange(deadPackList.Where(d => d.deadTriggerSkill != null).Select(d => d.deadTriggerSkill));
        foreach (var deadPack in deadPacksToRemove)
        {
            packList.Remove(deadPack);
        }
    }

    // 分配掉落物品：将掉落物品平均分配给死亡对象
    protected List<List<ItemModel>> AssignDrops(List<ItemModel> itemList, int deadCount)
    {
        var dropAssign = new List<List<ItemModel>>();
        for (int i = 0; i < deadCount; i++)
            dropAssign.Add(new List<ItemModel>());
        for (int i = 0; i < itemList.Count; i++)
            dropAssign[i % deadCount].Add(itemList[i]);
        return dropAssign;
    }

    // 获取包的 packUID
    protected ulong GetPackUID(GameNetPackBasic pack)
    {
        if (pack == null) return 0;

        if (pack is HB422_tagMCTurnFightObjDead deadPack)
            return deadPack.packUID;

        if (pack is CustomHB426CombinePack combinePack)
        {
            var mainSkillPack = combinePack.GetMainHB427SkillPack();
            return mainSkillPack?.packUID ?? 0;
        }

        if (pack is HB427_tagSCUseSkill skillPack)
            return skillPack.packUID;

        if (pack is HB428_tagSCBuffRefresh buffRefresh)
            return buffRefresh.packUID;

        if (pack is HB429_tagSCBuffDel buffDel)
            return buffDel.packUID;

        if (pack is HB419_tagSCObjHPRefresh hpRefresh)
            return hpRefresh.packUID;

        if (pack is HB405_tagMCAddExp expPack)
            return expPack.packUID;

        if (pack is H0704_tagRolePackRefresh dropPack)
            return dropPack.packUID;

        // 尝试通过反射获取 packUID
        var packUIDField = pack.GetType().GetField("packUID");
        if (packUIDField != null)
        {
            return (ulong)packUIDField.GetValue(pack);
        }

        return 0;
    }

    // 分配经验值：将经验包平均分配给每个死亡对象
    protected List<List<HB405_tagMCAddExp>> AssignExp(List<HB405_tagMCAddExp> expList, int deadCount)
    {
        var expAssign = new List<List<HB405_tagMCAddExp>>();
        for (int i = 0; i < deadCount; i++)
            expAssign.Add(new List<HB405_tagMCAddExp>());

        // 修复：检查除零风险
        if (deadCount == 0)
        {
            Debug.LogWarning("AssignExp: deadCount为0，无法分配经验");
            return expAssign;
        }

        // 修复：先收集要删除的包，避免在foreach中修改packList
        var expPacksToRemove = new List<HB405_tagMCAddExp>();

        foreach (var expPack in expList)
        {
            long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
            long avgExp = totalExp / deadCount;
            long remain = totalExp % deadCount;

            for (int i = 0; i < deadCount; i++)
            {
                long assignExp = avgExp + (i < remain ? 1 : 0);
                var newPack = new HB405_tagMCAddExp
                {
                    Exp = (uint)(assignExp % Constants.ExpPointValue),
                    ExpPoint = (uint)(assignExp / Constants.ExpPointValue),
                    Source = expPack.Source
                };
                expAssign[i].Add(newPack);
            }
            expPacksToRemove.Add(expPack);
        }

        // 统一删除收集的包
        foreach (var pack in expPacksToRemove)
        {
            packList.Remove(pack);
        }

        return expAssign;
    }

    /// <summary>
    /// 将 tempDeadPackList 里 pending 的死亡包投递给 BattleField 生成 DeathRecordAction。
    /// 合并 IsFinished（正常结束）与 ForceFinished（强制结束）两条路径的共同部分。
    /// </summary>
    /// <param name="useInnerPlayer">
    /// true：把 DeathRecordAction 绑定到 ownRecordAction（正常结束，死亡动作会等待当前技能完成）；
    /// false：不绑定（强制结束，死亡动作立即在默认 RecordPlayer 里播放）。
    /// </param>
    /// <param name="clearEvenIfNotDispatched">
    /// true：无论是否投递成功都清空 tempDeadPackList（ForceFinished 语义）；
    /// false：仅在成功投递 DeathRecordAction 时清空（IsFinished 语义）。
    /// </param>
    /// <returns>是否成功投递了 DeathRecordAction。</returns>
    protected bool FlushPendingDeathActions(bool useInnerPlayer, bool clearEvenIfNotDispatched)
    {
        //  防御：battleField / caster 任一为 null 时直接返回，避免 NullReferenceException。
        if (battleField == null || caster == null)
        {
            if (clearEvenIfNotDispatched) tempDeadPackList.Clear();
            return false;
        }

        //  统一做的事：从战场 casting 注册里移除自身。
        battleField.RemoveCastingSkill(caster.ObjID, this);

        var deadPacks = new List<BattleDeadPack>(tempDeadPackList.Values);
        //  两条路径的唯一差别：是否把 DeathRecordAction 绑定到 ownRecordAction（让死亡动作等技能完成）。
        DeathRecordAction recordAction = useInnerPlayer
            ? battleField.OnObjsDead(deadPacks, null, ownRecordAction)
            : battleField.OnObjsDead(deadPacks);

        if (null != recordAction && ownRecordAction != null)
        {
            ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAction);
            tempDeadPackList.Clear();
            return true;
        }

        if (clearEvenIfNotDispatched)
        {
            tempDeadPackList.Clear();
        }
        return false;
    }

    // 检查死亡后的包处理：处理技能包、掉落包、经验包
    protected void CheckAfterDeadhPack()
    {
        List<int> removeIndexList = new List<int>();

        for (int i = 0; i < packList.Count; i++)
        {
            var pack = packList[i];

            // 复活基本都靠技能包
            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
                break;

            if (pack is H0704_tagRolePackRefresh h0704Pack && h0704Pack.PackType == (byte)PackType.DropItem && h0704Pack.IsBind == 1)
            {
                dropPackList.Add(h0704Pack);
                removeIndexList.Add(i);
            }

            if (pack is HB405_tagMCAddExp h405Pack && h405Pack.Source == 2)
            {
                expPackList.Add(h405Pack);
                removeIndexList.Add(i);
            }
        }

        for (int i = removeIndexList.Count - 1; i >= 0; i--)
            packList.RemoveAt(removeIndexList[i]);
    }
}

 Main/System/Battle/Skill/SkillBase.Death.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: b94f32045be1dcd4793d5d0c275b969a
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.Finish.cs

New file
@@ -0,0 +1,464 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

// SkillBase（Finish 部分）：完成判定与强制结束。
public partial class SkillBase
{
    public virtual bool IsActionCompleted()
    {
        if (!isPlay) return false;

        if (skillEffect != null)
        {
            if (!skillEffect.IsFinished()) return false;
        }

        if (moveFinished)
        {
            //  如果技能有动画（SkillMotionName不为空），需要等待动画播放完成
            if (skillSkinConfig != null && !string.IsNullOrEmpty(skillSkinConfig.SkillMotionName))
            {
                if (!isMotionCompleted)
                {
                    BattleDebug.LogError($"SkillBase.IsActionCompleted: 技能 {skillConfig.SkillID} 等待动画播放完成");
                    return false;
                }
            }

            return true;
        }

        return false;
    }

    // 检查技能是否完成：综合检查所有完成条件
    public virtual bool IsFinished()
    {
        if (!isPlay)
        {
            ReportStuckIfNeeded("isPlay=false（OnSkillStart 未被调用或提前退出）");
            return false;
        }

        bool tempRetValue = true;

        // 检查技能效果是否完成
        if (skillEffect != null)
        {
            if (!skillEffect.IsFinished())
            {
                ReportStuckIfNeeded("skillEffect 未完成");
                return false;
            }
            skillEffect = null;
            OnSkillFinished();
            tempRetValue = false;
        }

        // 检查其他技能动作是否完成
        if (currentWaitingSkill.Count > 0)
        {
            if (currentWaitingSkill.Any(s => s.IsFinished()))
            {
                currentWaitingSkill.RemoveAll(s => s.IsFinished());
                OnSkillFinished();
            }
            else
            {
                tempRetValue = false;
            }
        }

        if (!tempRetValue)
        {
            if (currentWaitingSkill.Count > 0)
            {
                ReportStuckIfNeeded($"currentWaitingSkill 仍有 {currentWaitingSkill.Count} 个子动作");
            }
            return false;
        }


        // 检查最终完成状态
        if (isFinished && moveFinished)
        {
            if (packList.Count > 0)
            {
                OnSkillFinished();
                ReportStuckIfNeeded($"packList 仍剩 {packList.Count} 个包，ResolvePackList 未消费完");
                return false;
            }

            //  如果自己内部的recora action的 inner record player还有没执行完的包 也是返回false
            if (ownRecordAction != null && ownRecordAction.GetInnerRecordPlayer().IsPlaying())
            {
                ReportStuckIfNeeded("ownRecordAction.innerRecordPlayer.IsPlaying() == true（子 RecordAction 未播完）");
                return false;
            }

            // 技能完全结束，移除技能注册并触发延迟的死亡判定
            //  useInnerPlayer=true：DeathRecordAction 投到 ownRecordAction.innerRecordPlayer，等待当前技能完成
            //  clearEvenIfNotDispatched=false：保持原有行为，OnObjsDead 返回 null 时不清空缓存
            if (FlushPendingDeathActions(useInnerPlayer: true, clearEvenIfNotDispatched: false))
            {
                ReportStuckIfNeeded("FlushPendingDeathActions 投递了 DeathRecordAction，等待其播放完成");
                return false;
            }

            bool done = !ownRecordAction.GetInnerRecordPlayer().IsPlaying();
            if (!done) ReportStuckIfNeeded("末尾 innerRecordPlayer.IsPlaying() == true");
            else       ResetStuckCounter();
            return done;
        }

        ReportStuckIfNeeded($"isFinished={isFinished} moveFinished={moveFinished}（还没到末段）");
        return false;
    }

#if UNITY_EDITOR
    //  卡死侦测计数器：IsFinished 连续多少次返回 false。
    //  第 StuckThreshold 次首次 dump，之后每 StuckRepeatInterval 次再 dump，避免刷屏。
    private int _stuckCheckCount = 0;
    private string _lastStuckReason = null;
    private const int StuckThreshold = 120;        // ~2 秒（60fps）
    private const int StuckRepeatInterval = 180;   // ~3 秒
#endif

    /// <summary>
    /// 当 IsFinished 持续返回 false 时打一次详细诊断。reason 描述阻塞原因。
    /// 只在 UNITY_EDITOR + BattleDebug 开关下输出。
    /// </summary>
    private void ReportStuckIfNeeded(string reason)
    {
#if UNITY_EDITOR
        _stuckCheckCount++;

        //  阻塞原因切换了 → 立刻打一次，并重置计数
        bool reasonChanged = _lastStuckReason != reason;
        if (reasonChanged)
        {
            _lastStuckReason = reason;
            _stuckCheckCount = 1;
        }

        bool firstHit = _stuckCheckCount == StuckThreshold;
        bool repeat   = _stuckCheckCount > StuckThreshold
                     && (_stuckCheckCount - StuckThreshold) % StuckRepeatInterval == 0;

        if (!firstHit && !repeat) return;

        int skillId = skillConfig != null ? skillConfig.SkillID : 0;
        ulong casterId = tagUseSkillAttack != null ? tagUseSkillAttack.ObjID : 0UL;

        string subSkillDump = "  (无)";
        if (currentWaitingSkill.Count > 0)
        {
            var lines = new List<string>();
            for (int i = 0; i < currentWaitingSkill.Count; i++)
            {
                var s = currentWaitingSkill[i];
                lines.Add($"    [{i}] type={s.GetType().Name} IsFinished={s.IsFinished()}");
            }
            subSkillDump = string.Join("\n", lines);
        }

        string packListDump = "  (无)";
        if (packList != null && packList.Count > 0)
        {
            var lines = new List<string>();
            for (int i = 0; i < packList.Count && i < 8; i++)
            {
                var p = packList[i];
                string tag = p is CustomHB426CombinePack cb ? $" tag={cb.startTag?.Tag}" : "";
                lines.Add($"    [{i}] {p.GetType().Name}{tag}");
            }
            if (packList.Count > 8) lines.Add($"    ... 还有 {packList.Count - 8} 个");
            packListDump = string.Join("\n", lines);
        }

        bool innerPlaying = ownRecordAction != null && ownRecordAction.GetInnerRecordPlayer().IsPlaying();

        string innerPlayerDump = "  (innerRecordPlayer: 无)";
        if (ownRecordAction != null)
        {
            innerPlayerDump = "  innerRecordPlayer: " + ownRecordAction.GetInnerRecordPlayer().DumpPlayingState();
        }

        //  额外诊断：caster 动画状态 + SkillEffect 内部标志位 + 技能动作名
        string casterAnim = "  (caster 信息不可用)";
        if (caster is HeroBattleObject hbo && hbo.motionBase != null)
        {
            casterAnim = $"  caster.motionBase: playingSkillWithAnim={hbo.motionBase.PlayingSkillWithAnimForDebug}";
        }
        string skinInfo = $"  skillSkinConfig.SkillMotionName={(skillSkinConfig == null ? "null" : (string.IsNullOrEmpty(skillSkinConfig.SkillMotionName) ? "(空)" : skillSkinConfig.SkillMotionName))}";
        string skillEffectDump = skillEffect == null ? "  skillEffect=null" : $"  skillEffect: {skillEffect.DumpState()}";

        BattleDebug.LogError(
            "SkillBase.IsFinished 疑似卡死 (持续 " + _stuckCheckCount + " 次未完成)\n" +
            $"  skillId={skillId} caster={casterId} 原因: {reason}\n" +
            $"  StateFlags={_stateFlags}\n" +
            $"{skillEffectDump}\n" +
            $"{skinInfo}\n" +
            $"{casterAnim}\n" +
            $"  currentWaitingSkill.Count={currentWaitingSkill.Count}\n{subSkillDump}\n" +
            $"  packList.Count={(packList?.Count ?? 0)}\n{packListDump}\n" +
            $"  innerRecordPlayer.IsPlaying={innerPlaying}\n" +
            $"{innerPlayerDump}\n" +
            $"  tempDeadPackList.Count={tempDeadPackList.Count}\n" +
            $"  buffPackCollections.Count={buffPackCollections.Count}");
#endif
    }

    private void ResetStuckCounter()
    {
#if UNITY_EDITOR
        _stuckCheckCount = 0;
        _lastStuckReason = null;
#endif
    }


    // 强制结束技能：立即结束所有技能相关的处理
    public virtual void ForceFinished()
    {
        if (isFinished)
            return;

        //  强制结束路径：移除注册 + 投递死亡动作（不等技能完成，直接播放）+ 始终清空缓存。
        //  useInnerPlayer=false 保持原 ForceFinished 的行为（不指定 _playSkillRecordAction）。
        //  clearEvenIfNotDispatched=true 保持 ForceFinished 原有的"无论是否投递都 Clear"语义。
        FlushPendingDeathActions(useInnerPlayer: false, clearEvenIfNotDispatched: true);

        // 1. 强制结束技能效果
        skillEffect?.ForceFinished();
        skillEffect = null;

        // 2. 强制结束所有子技能动作
        if (currentWaitingSkill.Count > 0)
        {
            foreach (var skill in currentWaitingSkill)
            {
                skill.ForceFinish();
            }
            currentWaitingSkill.Clear();
        }

        // 3. 清理 DOTween 动画（防止移动回调在战斗结束后执行）
        if (caster != null)
        {
            caster.StopMoveAnimation();
        }

        // 4. 重置施法者状态
        if (caster != null)
        {
            // 重置位置到原点
            caster.ResetPosition();

            // 重置朝向
            caster.ResetFacing();

            // 取消幻影效果
            caster.ShowIllusionShadow(false);
        }

        // 5. 恢复 UI 状态
        if (battleField != null)
        {
            // 恢复所有角色的显示层级和血条
            var allList = battleField.battleObjMgr?.allBattleObjDict?.Values;
            if (allList != null)
            {
                foreach (BattleObject bo in allList)
                {
                    bo.layerMgr?.SetFront();
                    bo.GetHeroInfoBar()?.SetActive(true);
                }
            }

            // 关闭技能遮罩
            if (battleField.battleRootNode != null && battleField.battleRootNode.skillMaskNode != null)
            {
                battleField.battleRootNode.skillMaskNode.SetActive(false);
            }
        }

        isFinished = true;
        moveFinished = true;
        isPlay = true;

        //  强制结束时，无论是否有动画，都标记动画完成
        isMotionCompleted = true;

        // 6. 处理所有剩余包（包括 buff 包）
        // 先处理 buffPackCollections
        DistributeBuffPacks(buffPackCollections);
        buffPackCollections.Clear();

        // 处理剩余的 packList
        while (packList.Count > 0)
        {
            var pack = packList[0];
            packList.RemoveAt(0);

            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                var otherSkillAction = combinePack.CreateSkillAction();
                otherSkillAction.fromSkill = this;
                otherSkillAction.ForceFinish();
            }
            else
            {
                // 【使用 parentRecordAction.innerRecordPlayer】
                // 原因：ForceFinished时剩余的包也是技能内部产生的，应该由innerRecordPlayer管理
                // 这样可以确保即使强制结束，包的处理也在正确的上下文中
                PackageRegedit.Distribute(pack);
            }
        }
    }

    // 技能完成处理：正常完成时的清理工作
    public void OnSkillFinished()
    {
        // 修复：使用循环代替递归，避免栈溢出风险
        while (true)
        {
            // 验证技能效果是否完成
            if (skillEffect != null && !skillEffect.IsFinished())
                return;

            if (skillEffect != null)
            {
                skillEffect = null;
                continue; // 使用continue代替递归调用
            }

            // 验证其他技能动作是否完成
            if (currentWaitingSkill.Count > 0)
            {
                bool hasFinishedAction = currentWaitingSkill.All(s => s.IsFinished());

                if (hasFinishedAction)
                {
                    // 修复死循环：完成后需要清空 currentWaitingSkill
                    currentWaitingSkill.Clear();
                    continue; // 使用continue代替递归调用
                }
                return;
            }

            break; // 没有更多需要处理的，退出循环
        }

        // 处理剩余包
        if (!ResolvePackList())
        {
            return;
        }

        isFinished = true;
    }

    protected virtual bool ResolvePackList()
    {
        if (currentWaitingSkill.Count > 0)
        {
            return false;
        }

        while (packList.Count > 0)
        {
            var pack = packList[0];
            packList.RemoveAt(0);


            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                var skillRecordAction = combinePack.CreateSkillAction();
                skillRecordAction.fromSkill = this;
                currentWaitingSkill.Add(skillRecordAction);

                //  需要给真正parent播的
                if (skillRecordAction.useParentRecordPlayer && skillRecordAction.parentSkillAction != null)
                {
                    skillRecordAction.parentSkillAction.GetInnerRecordPlayer().PlayRecord(skillRecordAction);
                }
                else
                {
                    ownRecordAction.GetInnerRecordPlayer().PlayRecord(skillRecordAction);
                }

                return false;
            }
            else if (IsBuffPack(pack))
            {
                // 从找到第一个 Buff 包开始，收集连续的 HB428/HB429 包
                buffPackCollections.Add(pack);
                while (packList.Count > 0)
                {
                    var nextPack = packList[0];
                    if (IsBuffPack(nextPack))
                    {
                        buffPackCollections.Add(nextPack);
                        packList.RemoveAt(0);
                    }
                    else
                    {
                        break;
                    }
                }

                // 处理所有收集到的 buff 包
                ProcessBuffPacks(buffPackCollections);

                // 清空已处理的 buff 集合
                buffPackCollections.Clear();
                continue;
            }
            else
            {
                // 【使用 parentRecordAction.innerRecordPlayer】
                // 原因：技能执行过程中的包（Buff、属性刷新等）是技能效果的一部分
                // 应该由SkillRecordAction的innerRecordPlayer管理，确保与技能生命周期一致
                PackageRegeditEx.DistributeToRecordAction(pack, ownRecordAction);
            }
        }

        return true;
    }

    // 添加清理方法：防止内存泄漏
    public virtual void Cleanup()
    {
        tempDropList?.Clear();
        tempDeadPackList?.Clear();
        currentWaitingSkill?.Clear();
        dropPackList?.Clear();
        expPackList?.Clear();
        buffPackCollections?.Clear();

        skillEffect = null;
        packList = null;
    }

    public virtual bool CanStartExecution()
    {
        if (null == caster)
        {
            return false;
        }

        if (null == skillConfig)
        {
            return false;
        }

        if (string.IsNullOrEmpty(skillSkinConfig.SkillMotionName))
        {
            return true;
        }

        return !battleField.IsCastingSkill(caster.ObjID);
    }
}

 Main/System/Battle/Skill/SkillBase.Finish.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: a8ac29e3b0befe44c8eda664b3586454
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.Hit.cs

New file
@@ -0,0 +1,241 @@
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

// SkillBase（Hit 部分）：命中阶段——OnHit 分发到主目标 / 溅射目标 / 命中提示。
public partial class SkillBase
{
    // 命中目标回调：处理所有被命中的目标（包括主目标、弹射目标、溅射目标）
    protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
    {
        // Debug.LogError($"Skill {skillConfig.SkillID} hit targets _hitIndex: {_hitIndex} hit {string.Join(", ", hitList.Select(h => h.ObjID + ":" + battleField.battleObjMgr.GetBattleObject((int)h.ObjID)?.GetName()))}");

        //  造成伤害前先处理血量刷新包
        HandleRefreshHP();

        bool suckHp = true;

        // 处理主目标列表
        foreach (var hurt in hitList)
        {
            BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (target == null)
            {
                Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                continue;
            }

            OnHitEachTarget(_hitIndex, target, hurt, suckHp);

            suckHp = false;

            // 处理该目标的额外目标列表（如弹射伤害的平摊目标）
            if (hurt.HurtListEx != null && hurt.HurtListEx.Length > 0)
            {
                foreach (var hurtEx in hurt.HurtListEx)
                {
                    BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                    if (exTarget == null)
                    {
                        Debug.LogError($"额外目标为空 HurtListEx target == null ObjId : {hurtEx.ObjID}");
                        continue;
                    }

                    OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
                }
            }
        }

        // 处理技能包顶层的额外目标列表（如溅射伤害、平摊伤害）
        if (tagUseSkillAttack.HurtListEx != null && tagUseSkillAttack.HurtListEx.Length > 0)
        {
            foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
            {
                BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                if (exTarget == null)
                {
                    Debug.LogError($"顶层额外目标为空 tagUseSkillAttack.HurtListEx target == null ObjId : {hurtEx.ObjID}");
                    continue;
                }

                OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
            }
        }

        HandleHint(_hitIndex, hitList);
    }

    protected void HandleHint(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
    {
        if (0 == _hitIndex)
        {
            bool needhint = false;

            for (int i = 0; i < hitList.Count; i++)
            {
                var hurt = hitList[i];

                //8-击晕
                if ((hurt.AttackTypes & (int)DamageType.Stunned) == (int)DamageType.Stunned)
                {
                    needhint = true;
                    break;
                }

                for (int j = 0; j < hurt.HurtListEx?.Length; j++)
                {
                    var hurtex = hurt.HurtListEx[j];
                    //8-击晕
                    if ((hurtex.AttackTypes & (int)ServerDamageType.Stunned) == (int)ServerDamageType.Stunned)
                    {
                        needhint = true;
                        break;
                    }
                }

                if (needhint)
                    break;
            }

            if (needhint)
            {
                DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BattleStun);
                Hint(caster, hintConfig);
            }

            for (int i = 0; i < hitList.Count; i++)
            {
                var hurt = hitList[i];

                if ((hurt.AttackTypes & (int)DamageType.BreakArmor) == (int)DamageType.BreakArmor)
                {
                    BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (battleObject != null)
                    {
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BreakArmor);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject,
                            BattleConst.BreakArmorEffectID, battleObject.GetRectTransform(), battleObject.Camp,
                            battleObject.GetModelScale());
                    }
                }
                else if ((hurt.AttackTypes & (int)DamageType.Parry) == (int)DamageType.Parry)
                {
                    BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (battleObject != null)
                    {
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.Parry);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject,
                            BattleConst.ParryEffectID, battleObject.GetRectTransform(), battleObject.Camp,
                            battleObject.GetModelScale());
                    }
                }
            }
        }
    }

    // 处理单个目标被命中:应用伤害和施法者效果
    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt, bool suckHp)
    {
        // ============ 获取临时数据(掉落、死亡等) ============
        int objID = (int)target.ObjID;
        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
        tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);

        // 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
        if (battleField != null && battleField.IsCastingSkill(target.ObjID))
        {
            deadPack = null;
        }

        // ============ 参数打包 ============
        BattleHurtParam hurtParam = BattleUtility.CalcBattleHurtParam(this, _hitIndex, target, hurt, battleDrops, deadPack, suckHp);
#if UNITY_EDITOR
        PrintHurtParamDebugInfo(hurtParam);
#endif

        // 先调用目标受伤
        DeathRecordAction recordAc = target.Hurt(hurtParam, ownRecordAction);

        if (null != recordAc)
        {
            tempDeadPackList.Remove(hurtParam.hurter.hurtObj.ObjID);
            ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAc, ownRecordAction, true);
            currentWaitingSkill.Add(recordAc);
        }

        // 再调用施法者吸血/反伤
        caster.OnHurtTarget(hurtParam);
    }

    // 处理额外目标被命中（HurtListEx）：溅射、弹射、平摊伤害等
    protected virtual void OnHitEachTargetEx(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurtEx hurtEx)
    {
        // ============ 获取临时数据(掉落、死亡等) ============
        int objID = (int)target.ObjID;
        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);

        tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);

        // 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
        if (battleField != null && battleField.IsCastingSkill(target.ObjID))
        {
            deadPack = null;
        }
        // ============ 参数打包（将 tagSCUseSkillHurtEx 转换为 tagSCUseSkillHurt）============
        HB427_tagSCUseSkill.tagSCUseSkillHurt hurt = new HB427_tagSCUseSkill.tagSCUseSkillHurt
        {
            ObjID = hurtEx.ObjID,
            AttackTypes = hurtEx.AttackTypes,
            HurtHP = hurtEx.HurtHP,
            HurtHPEx = hurtEx.HurtHPEx,
            CurHP = hurtEx.CurHP,
            CurHPEx = hurtEx.CurHPEx,
            SuckHP = 0,//hurtEx.SuckHP, 获取全部吸血时已经计算过 这里就不再计算
            BounceHP = 0, // HurtEx 没有反伤字段
            HurtCountEx = 0,
            HurtListEx = null
        };

        OnHitEachTarget(_hitIndex, target, hurt, false);//获取全部吸血时已经计算过 这里就不再计算
    }

#if UNITY_EDITOR
    private void PrintHurtParamDebugInfo(BattleHurtParam hurtParam)
    {
        bool isLastHit = hurtParam.hitIndex >= hurtParam.skillSkinConfig.DamageDivide.Length - 1;

        long currentHitDamage = hurtParam.hurter.damageList != null ? hurtParam.hurter.damageList.Sum() : 0;
        long currentHitSuckHp = hurtParam.caster.suckHpList != null ? hurtParam.caster.suckHpList.Sum() : 0;
        long currentHitReflectHp = hurtParam.caster.reflectHpList != null ? hurtParam.caster.reflectHpList.Sum() : 0;

        long totalDamage = GeneralDefine.GetFactValue(hurtParam.hurt.HurtHP, hurtParam.hurt.HurtHPEx);
        long totalSuckHp = BattleUtility.GetSuckHp(tagUseSkillAttack);
        long totalReflectHp = hurtParam.hurt.BounceHP;

        BattleDebug.LogError(
            (hurtParam.caster.casterObj.Camp == BattleCamp.Red ? "【红方行动】" : "【蓝方行动】 ") +
            $"攻击者: {hurtParam.caster.casterObj.GetName()} (ObjID:{hurtParam.caster.casterObj.ObjID})\n" +
            $"目标: {hurtParam.hurter.hurtObj.GetName()} (ObjID:{hurtParam.hurter.hurtObj.ObjID})\n" +
            $"技能: {hurtParam.skillConfig.SkillName} (ID:{hurtParam.skillConfig.SkillID})\n" +
            $"击数: 第{hurtParam.hitIndex + 1}击 / 共{hurtParam.skillSkinConfig.DamageDivide.Length}击" + (isLastHit ? " [最后一击]" : " [中间击]") + "\n" +
            $"\n" +
            $"========== 目标受伤数据 ==========\n" +
            $"伤害: {currentHitDamage} / 总伤害: {totalDamage}\n" +
            $"伤害分段: [{string.Join(", ", hurtParam.hurter.damageList ?? new System.Collections.Generic.List<long>())}]\n" +
            $"目标血量: {hurtParam.hurter.fromHp} -> {hurtParam.hurter.toHp} (最大:{hurtParam.hurter.maxHp})\n" +
            $"目标护盾: {hurtParam.hurter.fromShieldValue} -> {hurtParam.hurter.toShieldValue}\n" +
            $"攻击类型: {hurtParam.hurt.AttackTypes}\n" +
            $"\n" +
            $"========== 施法者数据 ==========\n" +
            $"吸血: {currentHitSuckHp} / 总吸血: {totalSuckHp}\n" +
            $"吸血分段: [{string.Join(", ", hurtParam.caster.suckHpList ?? new System.Collections.Generic.List<long>())}]\n" +
            $"反伤: {currentHitReflectHp} / 总反伤: {totalReflectHp}\n" +
            $"反伤分段: [{string.Join(", ", hurtParam.caster.reflectHpList ?? new System.Collections.Generic.List<long>())}]\n" +
            $"施法者血量: {hurtParam.caster.fromHp} -> {hurtParam.caster.toHp} (最大:{hurtParam.caster.maxHp})\n" +
            $"施法者护盾: {hurtParam.caster.fromShieldValue} -> {hurtParam.caster.toShieldValue}\n"
        );
    }
#endif
}

 Main/System/Battle/Skill/SkillBase.Hit.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 51400dced66a2be438fb359d60a01280
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.SubSkill.cs

New file
@@ -0,0 +1,86 @@
using System.Collections.Generic;
using UnityEngine;

// SkillBase（SubSkill 部分）：前置内嵌子技能的收集与投递。
//
// 规则：
//   从 packList 头部连续收集"纯静默前置子技能"（没有动作、非死亡复活、不触发死亡）
//   直到遇到任何一个"需要等待"的包（带动作/SkillType==8/HB422）就停止。
//   已收集的前置子技能按 packUID 排序后投递到 ownRecordAction.innerRecordPlayer。
//
// 子技能递归判断：
//   当遇到 CustomHB426CombinePack 时，使用 combinePack.NeedWaiting() 判断，
//   NeedWaiting 内部会递归检查嵌套的 CustomHB426CombinePack，
//   因此"子技能里面的子技能"也会被正确判断。
public partial class SkillBase
{
    protected void ProcessSubSkill()
    {
        // 按packUID排序所有子技能
        var allSubSkills = new List<(ulong packUID, SkillRecordAction action)>();

        List<GameNetPackBasic> removePackList = new List<GameNetPackBasic>();

        foreach (var pack in packList)
        {
            if (pack is HB427_tagSCUseSkill skillPack)
            {
                SkillConfig ssc = SkillConfig.Get((int)skillPack.SkillID);
                SkillSkinConfig sscSkin = ssc.GetOriginSkinConfig();
                if (!string.IsNullOrEmpty(sscSkin.SkillMotionName))
                {
                    break;
                }
                if (ssc.SkillType == 8)
                {
                    break;
                }
                SkillRecordAction skillRecordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic> { skillPack });
                allSubSkills.Add((skillPack.packUID, skillRecordAction));
                removePackList.Add(pack);
            }
            else if (pack is HB422_tagMCTurnFightObjDead dead)
            {
                break;
            }
            else if (pack is CustomHB426CombinePack combinePack)
            {
                // 递归判断：combinePack 自身或其嵌套包里只要含有动作 / SkillType==8 / HB422，
                // 就视为"需要等待"，不作为静默前置子技能处理，
                // 留给后续 ResolvePackList 走正常队列流程。
                // NeedWaiting() 内部已递归遍历嵌套的 CustomHB426CombinePack。
                if (combinePack.NeedWaiting())
                {
                    break;
                }

                HB427_tagSCUseSkill sp = combinePack.GetMainHB427SkillPack();
                SkillRecordAction skillRecordAction = combinePack.CreateSkillAction();
                allSubSkills.Add((sp.packUID, skillRecordAction));
                removePackList.Add(pack);
            }
        }

        for (int i = 0; i < removePackList.Count; i++)
        {
            packList.Remove(removePackList[i]);
        }

        // 按packUID排序
        allSubSkills.Sort((a, b) => a.packUID.CompareTo(b.packUID));

        foreach (var (packUID, recordAction) in allSubSkills)
        {
            // 经过 NeedWaiting 过滤后，此处 recordAction.useParentRecordPlayer 理论上始终为 false，
            // 保留分支是防御式编码，行为与原实现一致。
            if (recordAction.useParentRecordPlayer)
            {
                ownRecordAction.GetInnerRecordPlayer().PlayRecord(recordAction, ownRecordAction);
            }
            else
            {
                ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAction);
            }
        }
    }
}

 Main/System/Battle/Skill/SkillBase.SubSkill.cs.meta

New file
@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 30efa070918de9a47a0a4937b69340b8
MonoImporter:
  externalObjects: {}
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Main/System/Battle/Skill/SkillBase.cs

@@ -1,12 +1,22 @@
using System.Collections.Generic;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using Spine;
using System.Linq;
using System;

public class SkillBase
// SkillBase：技能运行时基类。
// 本类使用 partial 拆分为多个文件，按职责分组：
//   SkillBase.cs             字段、构造、公共入口（Cast/Run/OnSkillStart/各 Frame 回调 等）
//   SkillBase.Cast.cs        施法阶段：移动、动画、残影、高亮、攻击回合结束
//   SkillBase.Hit.cs         命中阶段：OnHit 分发到主目标 / 溅射目标 / 命中提示
//   SkillBase.SubSkill.cs    前置内嵌子技能的收集与投递
//   SkillBase.Death.cs       死亡包与掉落/经验分配
//   SkillBase.Buff.cs        Buff 包（HB428/HB429）的收集与分发
//   SkillBase.Finish.cs      完成判定与强制结束
public partial class SkillBase
{
    // ===== 常量 =====
    const float moveTime = 0.5f;

    private static readonly Color colorGreen = new Color(33f / 255f,
@@ -16,40 +26,115 @@
                                                        87f / 255f,
                                                        189f / 255f);

    protected SkillEffect skillEffect;
    // ===== 核心引用 =====
    public HB427_tagSCUseSkill tagUseSkillAttack;
    public SkillConfig skillConfig;

    public SkillSkinConfig skillSkinConfig;
    protected bool isFinished = false;
    public BattleObject caster = null; // 施法者
    protected BattleField battleField = null; // 战场
    protected RectTransform targetNode = null; // 目标节点
    public BattleObject caster = null; // 施法者
    protected List<GameNetPackBasic> packList;

    // ===== 命中效果 =====
    protected SkillEffect skillEffect;

    // ===== 子技能/子动作等待列表 =====
    protected List<RecordAction> currentWaitingSkill = new List<RecordAction>();

    // ===== 死亡相关临时数据 =====
    protected List<H0704_tagRolePackRefresh> dropPackList = new List<H0704_tagRolePackRefresh>();
    protected List<HB405_tagMCAddExp> expPackList = new List<HB405_tagMCAddExp>();

    protected bool moveFinished = false;
    public SkillBase fromSkill;
    public bool isPlay = false;

    //  父RecordAction（SkillRecordAction），用于子技能建立父子关系
    protected SkillRecordAction ownRecordAction;
    
    //  技能动画是否播放完成（针对有动画的技能）
    protected bool isMotionCompleted = false;

    private float MoveSpeed = 750f;

    private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
    private Dictionary<int, BattleDeadPack> tempDeadPackList = new Dictionary<int, BattleDeadPack>();

    // Buff相关包集合，支持 HB428(刷新) 和 HB429(删除)
    // ===== Buff 相关包集合，支持 HB428(刷新) 和 HB429(删除) =====
    protected List<GameNetPackBasic> buffPackCollections = new List<GameNetPackBasic>();

    // ===== 生命周期状态（4 个并行里程碑位，合并到同一 Flags 字段） =====
    //   Started        : 已进入施法阶段（OnSkillStart 调用后）
    //   MoveCompleted  : 位移已收尾（OnAllAttackMoveFinished）
    //   MotionCompleted: 技能动画已播放完（OnFinalFrameEnd）
    //   Finished       : 包列表已处理完（OnSkillFinished / ForceFinished 结尾）
    //   4 个里程碑相互独立，非线性阶段，不能用单一 state 表达。
    [System.Flags]
    protected enum SkillStateFlags
    {
        None            = 0,
        Started         = 1 << 0,
        MoveCompleted   = 1 << 1,
        MotionCompleted = 1 << 2,
        Finished        = 1 << 3,
    }

    private SkillStateFlags _stateFlags = SkillStateFlags.None;

    /// <summary>当前技能状态位（只读，调试用）。</summary>
    protected SkillStateFlags StateFlags => _stateFlags;

#if UNITY_EDITOR
    /// <summary>供外部调试/诊断打印用，非编辑器下不编译。</summary>
    public string StateFlagsForDebug => _stateFlags.ToString();
#endif

    /// <summary>是否已进入施法阶段（OnSkillStart 调用后为 true）。</summary>
    public bool isPlay
    {
        get => (_stateFlags & SkillStateFlags.Started) != 0;
        set => SetFlag(SkillStateFlags.Started, value);
    }

    /// <summary>包列表是否已全部处理完。</summary>
    protected bool isFinished
    {
        get => (_stateFlags & SkillStateFlags.Finished) != 0;
        set => SetFlag(SkillStateFlags.Finished, value);
    }

    /// <summary>位移是否已收尾。</summary>
    protected bool moveFinished
    {
        get => (_stateFlags & SkillStateFlags.MoveCompleted) != 0;
        set => SetFlag(SkillStateFlags.MoveCompleted, value);
    }

    /// <summary>技能动画是否已播放完。</summary>
    protected bool isMotionCompleted
    {
        get => (_stateFlags & SkillStateFlags.MotionCompleted) != 0;
        set => SetFlag(SkillStateFlags.MotionCompleted, value);
    }

    private void SetFlag(SkillStateFlags flag, bool value)
    {
#if UNITY_EDITOR
        //  记录状态变更：卡死/卡活的排查利器。
        //  编辑器下只在值真正发生改变时打印，避免刷屏。
        bool oldValue = (_stateFlags & flag) != 0;
        if (oldValue != value)
        {
            int skillId = skillConfig != null ? skillConfig.SkillID : 0;
            ulong casterId = tagUseSkillAttack != null ? tagUseSkillAttack.ObjID : 0UL;
            BattleDebug.LogError(
                $"SkillBase.StateFlags 变更:skillId={skillId} caster={casterId} " +
                $"{flag}: {oldValue} -> {value}  (before={_stateFlags})");
        }
#endif

        if (value) _stateFlags |= flag;
        else       _stateFlags &= ~flag;
    }

    // ===== 父子关系 =====
    public SkillBase fromSkill;
    //  父RecordAction（SkillRecordAction），用于子技能建立父子关系
    protected SkillRecordAction ownRecordAction;

    // ===== 移动速度（残影加速时会改变） =====
    private float MoveSpeed = 750f;

#if UNITY_EDITOR
    public static Dictionary<string, string> changeListDict = new Dictionary<string, string>();
#endif

    // 构造函数：初始化技能基础数据
    public SkillBase(BattleObject _caster, SkillConfig _skillCfg, HB427_tagSCUseSkill vNetData, List<GameNetPackBasic> _packList, BattleField _battleField = null)
@@ -73,7 +158,7 @@
        {
            skillSkinConfig = skillConfig.GetOriginSkinConfig();
        }
        


        // 注册正在释放的技能
        if (battleField != null && caster != null)
@@ -86,7 +171,7 @@

    public virtual void AfterAddToQueue()
    {
        

    }

    //  设置父RecordAction
@@ -95,31 +180,28 @@
        ownRecordAction = recordAction;
    }

#if UNITY_EDITOR
    public static Dictionary<string, string> changeListDict = new Dictionary<string, string>();
#endif
    private void PinrtHB427Hp()
    {
#if UNITY_EDITOR
        string skillDetail = "SkillCaster : " + tagUseSkillAttack.ObjID + " -> cast SkillID: " + skillConfig.SkillID + "\n";
        

        skillDetail += "------------------ HurtList ------------------\n";
        for (int i = 0; i < tagUseSkillAttack.HurtCount; i++)
        {
            var Hurt = tagUseSkillAttack.HurtList[i];
            BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)Hurt.ObjID);
            

            string targetName = battleObject != null ? battleObject.GetName() : "Unknown";
            long hurtHp = GeneralDefine.GetFactValue(Hurt.HurtHP, Hurt.HurtHPEx);
            long curHp = GeneralDefine.GetFactValue(Hurt.CurHP, Hurt.CurHPEx);
            

            skillDetail += $"  [{i}] Target: {targetName} (ObjID:{Hurt.ObjID})\n";
            skillDetail += $"      HurtHP: {hurtHp}\n";
            skillDetail += $"      CurHP: {curHp}\n";
            skillDetail += $"      SuckHP: {Hurt.SuckHP}\n";
            skillDetail += $"      BounceHP: {Hurt.BounceHP}\n";
            skillDetail += $"      AttackTypes: {Hurt.AttackTypes}\n";
            

            if (Hurt.HurtListEx != null && Hurt.HurtListEx.Length > 0)
            {
                skillDetail += $"      HurtListEx ({Hurt.HurtListEx.Length}):\n";
@@ -128,7 +210,7 @@
                    var hurtEx = Hurt.HurtListEx[j];
                    long hurtExHp = GeneralDefine.GetFactValue(hurtEx.HurtHP, hurtEx.HurtHPEx);
                    long curExHp = GeneralDefine.GetFactValue(hurtEx.CurHP, hurtEx.CurHPEx);
                    

                    skillDetail += $"        [{j}] ObjID:{hurtEx.ObjID} HurtHP:{hurtExHp} CurHP:{curExHp} SuckHP:{hurtEx.SuckHP} AttackTypes:{hurtEx.AttackTypes}\n";
                }
            }
@@ -141,11 +223,11 @@
            {
                var HurtEx = tagUseSkillAttack.HurtListEx[i];
                BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)HurtEx.ObjID);
                

                string targetName = battleObject != null ? battleObject.GetName() : "Unknown";
                long hurtHp = GeneralDefine.GetFactValue(HurtEx.HurtHP, HurtEx.HurtHPEx);
                long curHp = GeneralDefine.GetFactValue(HurtEx.CurHP, HurtEx.CurHPEx);
                

                skillDetail += $"  [{i}] Target: {targetName} (ObjID:{HurtEx.ObjID})\n";
                skillDetail += $"      HurtHP: {hurtHp}\n";
                skillDetail += $"      CurHP: {curHp}\n";
@@ -161,7 +243,7 @@
            string origin = changeListDict[caster.battleField.guid];
            origin += skillDetail;
            changeListDict[caster.battleField.guid] = origin;
            

        }
        else
            changeListDict.Add(caster.battleField.guid, skillDetail);
@@ -179,19 +261,17 @@
        }
#endif

        bool safety = caster != null 
                        && skillConfig != null 
                        && tagUseSkillAttack != null 
        bool safety = caster != null
                        && skillConfig != null
                        && tagUseSkillAttack != null
                        && battleField != null;

        

        if (!safety)
        {
            Debug.LogError("SkillBase SafetyCheck failed! Caster or SkillConfig or TagUseSkillAttack or BattleField is null, or Caster is dead.");
            ForceFinished();
        }

        
    }

    // 技能运行主逻辑：处理技能效果和其他技能动作
@@ -210,290 +290,6 @@
            }
            return;
        }


    }

    protected void ShadowIllutionCreate(bool create)
    {
        if (create)
        {
            Color color = Color.white;
            //1-连击；2-反击；3-追击
            //  反击蓝色
            //  追击连击绿色
            bool change = false;
            if (tagUseSkillAttack.BattleType == 1)
            {
                color = colorGreen;
                change = true;
            }
            else if (tagUseSkillAttack.BattleType == 2)
            {
                color = colorBlue;
                change = true;
            }
            else if (tagUseSkillAttack.BattleType == 3)
            {
                color = colorGreen;
                change = true;
            }
            
            if (change)
            {
                MoveSpeed = 1125f;
                caster.ShowIllusionShadow(true, color);
            }
        }
        else
        {
            MoveSpeed = 750f;
            caster.ShowIllusionShadow(false);
        }
    }

    // 技能释放主逻辑：广播事件、高亮目标、执行释放
    public virtual void Cast()
    {
        // 广播技能释放事件
        string guid = battleField.guid;
        // 获取释放者数据：Hero 传递 teamHero，Mingge 传递 null（因为事件监听器只处理 Hero 数据）
        TeamHero teamHero = null;
        if (caster is HeroBattleObject heroBattleObject)
        {
            teamHero = heroBattleObject.teamHero;
        }
        // 命格释放技能时 teamHero 为 null，监听器会正确处理（已有 null 检查）
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);

        if (skillSkinConfig.SkinllSFX1 != 0)
        {
            battleField.soundManager.PlayEffectSound(skillSkinConfig.SkinllSFX1, false);
        }

        if (caster != null)
        {
            // 战斗类型 0-常规；1-连击；2-反击；3-追击；4-子技能；5-被动触发的
            DamageNumConfig hintConfig = null;
            if (tagUseSkillAttack.BattleType == 1)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleComboAttack);
            }
            else if (tagUseSkillAttack.BattleType == 2)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleCounterAttack);
            }
            else if (tagUseSkillAttack.BattleType == 3)
            {
                hintConfig = DamageNumConfig.Get(BattleConst.BattleChaseAttack);
            }
            
            Hint(caster, hintConfig);


        }

        // 高亮所有本次技能相关的目标
        HighLightAllTargets();

        // 根据释放模式执行相应逻辑
        switch (skillSkinConfig.castMode)
        {
            case SkillCastMode.None:
            case SkillCastMode.Self:
                CastImpl(OnAttackFinish);
                break;
            case SkillCastMode.Enemy:
                CastToEnemy();
                break;
            case SkillCastMode.Target:
                CastToTarget();
                break;
            case SkillCastMode.Allies:
                CastToAllies();
                break;
            case SkillCastMode.DashCast:
                DashCast(OnAttackFinish);
                break;
            default:
                Debug.LogError("强制结束技能 暂时不支持其他的方式释放 有需求please联系策划 技能id:" + skillConfig.SkillID + " cast position " + skillSkinConfig.CastPosition);
                ForceFinished();
                break;
        }
    }

    protected void Hint(BattleObject battleObject, DamageNumConfig hintConfig)
    {
        if (hintConfig != null)
        {
            battleObject.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
        }
    }

    // 冲撞攻击模式（待实现）
    protected void DashCast(Action _onComplete)
    {
        Debug.LogError("DashCast 还没实现");
        ForceFinished();
    }

    // 对敌方释放技能：移动到敌方区域进行攻击
    protected void CastToEnemy()
    {
        RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillSkinConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            if (skillConfig.ClientTriggerTiming == 1)
            {
                OnAttackFinish();
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.GetPositionNum()), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);   
            }
        });
    }

    // 对指定目标释放技能：移动到主要目标位置进行攻击
    protected void CastToTarget()
    {
        if (tagUseSkillAttack.HurtCount <= 0)
        {
            Debug.LogError("技能攻击包没有目标 HurtCount <= 0");
            OnSkillFinished();
            return;
        }

        int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(this, caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
        BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
        RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);

        ExecuteMoveAndCastSequence(targetTrans, () =>
        {
            RectTransform rectTransform = battleField.GetTeamNode(caster.Camp, caster.GetPositionNum());
            // ShadowIllutionCreate(true);
            MoveToTarget(rectTransform, Vector2.zero, () =>
            {
                // ShadowIllutionCreate(false);
                OnAttackFinish();
            }, MoveSpeed);
        });
    }

    // 对友方释放技能：移动到友方区域进行治疗或增益
    protected void CastToAllies()
    {
        RectTransform target = battleField.GetTeamNode(caster.Camp, skillSkinConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            if (skillConfig.ClientTriggerTiming == 1)
            {
                OnAttackFinish();
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.GetPositionNum()), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);   
            }
        });
    }

    // 执行移动-施法-返回序列：通用的移动攻击流程
    private void ExecuteMoveAndCastSequence(RectTransform target, Action onReturnComplete)
    {
        ShadowIllutionCreate(true);
        MoveToTarget(target, new Vector2(skillSkinConfig.CastDistance, 0), () =>
        {
            if (skillSkinConfig.CastDistance < 9999 && skillSkinConfig.SkinllSFX2 != 0)
            {
                battleField.soundManager.PlayEffectSound(skillSkinConfig.SkinllSFX2, false);
            }

            TurnBack(() =>
            {
                ShadowIllutionCreate(false);
                
                CastImpl(() =>
                {
                    TurnBack(() => 
                    {
                        try
                        {
                            onReturnComplete?.Invoke(); // 添加异常处理防止回调异常导致状态不完整
                        }
                        catch (Exception ex)
                        {
                            Debug.LogError($"ExecuteMoveAndCastSequence回调异常: {ex.Message}");
                            throw;
                        }
                    }, -1f);
                });
            }, -1f);
        });
    }

    // 移动到目标位置：处理角色的移动动画和逻辑
    protected void MoveToTarget(RectTransform target, Vector2 offset, Action _onComplete = null, float speed = 750f)
    {
        if (skillSkinConfig.CastDistance >= 9999)
        {
            _onComplete?.Invoke();
            return;
        }

        caster.PlayAnimation(MotionName.run, true);
        var tweener = BattleUtility.MoveToTarget(caster.GetRectTransform(), target, offset, () =>
        {
            caster.PlayAnimation(MotionName.idle, true);
            _onComplete?.Invoke();
        }, speed);
        battleField.battleTweenMgr.OnPlayTween(tweener);
    }

    // 转身逻辑：根据技能配置处理角色转向
    protected void TurnBack(Action _onComplete, float forward)
    {
        if (skillSkinConfig.CastDistance < 0)
        {
            caster.SetFacing(forward);
        }
        _onComplete?.Invoke();
    }

    // 攻击完成后的处理：转身、恢复状态、播放待机动画
    protected void OnAttackFinish()
    {
        TurnBack(null, 1f);
        OnAllAttackMoveFinished();
        caster.PlayAnimation(MotionName.idle, true);
    }

    // 所有攻击移动完成后的处理：恢复UI显示状态
    protected virtual void OnAllAttackMoveFinished()
    {
        moveFinished = true;
        List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
        foreach (BattleObject bo in allList)
        {
            bo.layerMgr.SetFront();
            bo.GetHeroInfoBar()?.SetActive(true);
        }
        battleField.battleRootNode.skillMaskNode.SetActive(false);
    }

    // 执行技能释放动画和逻辑：播放施法动作并提供回调
    protected TrackEntry CastImpl(Action onComplete = null)
    {
        return caster.PlaySkillAnimation(skillConfig, skillSkinConfig, this, tagUseSkillAttack.BattleType == 4, onComplete);
    }

    // 技能开始回调：处理死亡、子技能、技能效果初始化
@@ -513,86 +309,12 @@

        skillEffect = SkillEffectFactory.CreateSkillEffect(this, caster, skillConfig, skillSkinConfig, tagUseSkillAttack);
        skillEffect.Play(OnHitTargets);
        


        isPlay = true;
    }

    protected void ProcessSubSkill()
    {
        // 按packUID排序所有子技能
        var allSubSkills = new List<(ulong packUID, SkillRecordAction action)>();
        
        List<GameNetPackBasic> removePackList = new List<GameNetPackBasic>();

        foreach (var pack in packList)
        {
            if (pack is HB427_tagSCUseSkill skillPack)
            {
                SkillConfig ssc = SkillConfig.Get((int)skillPack.SkillID);
                SkillSkinConfig sscSkin = ssc.GetOriginSkinConfig();
                if (!string.IsNullOrEmpty(sscSkin.SkillMotionName))
                {
                    break;
                }
                if (ssc.SkillType == 8)
                {
                    break;
                }
                SkillRecordAction skillRecordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic> { skillPack });
                allSubSkills.Add((skillPack.packUID, skillRecordAction));
                removePackList.Add(pack);
            }
            else if (pack is HB422_tagMCTurnFightObjDead dead)
            {
                break;
            }
            else if (pack is CustomHB426CombinePack combinePack)
            {
                HB427_tagSCUseSkill sp = combinePack.GetMainHB427SkillPack();
                SkillConfig ssc = SkillConfig.Get((int)sp.SkillID);
                SkillSkinConfig sscSkin = ssc.GetOriginSkinConfig();
                if (!string.IsNullOrEmpty(sscSkin.SkillMotionName))
                {
                    break;
                }

                if (ssc.SkillType == 8)
                {
                    break;
                }
                
                SkillRecordAction skillRecordAction = combinePack.CreateSkillAction();
                allSubSkills.Add((sp.packUID, skillRecordAction));
                removePackList.Add(pack);

                if (skillRecordAction.useParentRecordPlayer)
                {
                    break;
                }
            }
        }

        for (int i = 0; i < removePackList.Count; i++)
        {
            packList.Remove(removePackList[i]);
        }

        // 按packUID排序
        allSubSkills.Sort((a, b) => a.packUID.CompareTo(b.packUID));

        foreach (var (packUID, recordAction) in allSubSkills)
        {
            if (recordAction.useParentRecordPlayer)
            {
                ownRecordAction.GetInnerRecordPlayer().PlayRecord(recordAction, ownRecordAction);
            }
            else
            {
                ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAction);
            }
        }
    }
    // ===== 技能节拍回调 =====

    // 技能前摇结束回调
    public virtual void OnStartSkillFrameEnd() { }
@@ -621,1019 +343,7 @@
        //  标记动画播放完成
        isMotionCompleted = true;
        BattleDebug.LogError($"SkillBase.OnFinalFrameEnd: 技能 {skillConfig?.SkillID} 动画播放完成");
        

        skillEffect?.OnFinalFrameEnd(); // 修复：添加空值检查
    }

    // 高亮所有相关目标：设置施法者和目标的显示层级
    protected void HighLightAllTargets()
    {
        caster.layerMgr.SetSortingOrder(BattleConst.SkillMaskOrder + 1);// offset是3 英雄层级 +1就是 active级别 

        if (skillConfig.FuncType != 2)
            return;

        // 收集所有目标（包含 HurtList、每个 Hurt 的 HurtListEx、以及顶层 HurtListEx）
        var targetSet = new HashSet<BattleObject>();
        if (tagUseSkillAttack != null)
        {
            // 主目标列表
            if (tagUseSkillAttack.HurtList != null)
            {
                foreach (var hurt in tagUseSkillAttack.HurtList)
                {
                    var bo = battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (bo != null) targetSet.Add(bo);

                    // 主目标的额外目标（弹射/平摊）
                    if (hurt.HurtListEx != null)
                    {
                        foreach (var hurtEx in hurt.HurtListEx)
                        {
                            var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                            if (exBo != null) targetSet.Add(exBo);
                        }
                    }
                }
            }

            // 技能包顶层的 HurtListEx（如溅射、顶层平摊）
            if (tagUseSkillAttack.HurtListEx != null)
            {
                foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
                {
                    var exBo = battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                    if (exBo != null) targetSet.Add(exBo);
                }
            }
        }

        // 确保施法者也被高亮（原逻辑）
        var highlightList = new List<BattleObject>(targetSet) { caster };

        var allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList();

        // 构造集合便于判断
        var targetSetLookup = new HashSet<BattleObject>(targetSet);
        var highlightSet = new HashSet<BattleObject>(highlightList);

        // 先把施法者的 InfoBar 隐藏（原逻辑保留）
        caster.GetHeroInfoBar()?.SetActive(false);

        foreach (BattleObject bo in allList)
        {
            bool isHighlight = highlightSet.Contains(bo);
            bool isTarget = targetSetLookup.Contains(bo);

            if (isHighlight)
            {
                bo.layerMgr.SetFront();
            }
            else
            {
                bo.layerMgr.SetBack();
            }

            // 目标（含 HurtListEx）都应显示 InfoBar
            bo.GetHeroInfoBar()?.SetActive(isTarget);
        }

        battleField.battleRootNode.skillMaskNode.SetActive(true);
    }


    // 命中目标回调：处理所有被命中的目标（包括主目标、弹射目标、溅射目标）
    protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
    {
        // Debug.LogError($"Skill {skillConfig.SkillID} hit targets _hitIndex: {_hitIndex} hit {string.Join(", ", hitList.Select(h => h.ObjID + ":" + battleField.battleObjMgr.GetBattleObject((int)h.ObjID)?.GetName()))}");

        //  造成伤害前先处理血量刷新包
        HandleRefreshHP();

        bool suckHp = true;

        // 处理主目标列表
        foreach (var hurt in hitList)
        { 
            BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (target == null)
            {
                Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                continue;
            }

            OnHitEachTarget(_hitIndex, target, hurt, suckHp);

            suckHp = false;

            // 处理该目标的额外目标列表（如弹射伤害的平摊目标）
            if (hurt.HurtListEx != null && hurt.HurtListEx.Length > 0)
            {
                foreach (var hurtEx in hurt.HurtListEx)
                {
                    BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                    if (exTarget == null)
                    {
                        Debug.LogError($"额外目标为空 HurtListEx target == null ObjId : {hurtEx.ObjID}");
                        continue;
                    }

                    OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
                }
            }
        }

        // 处理技能包顶层的额外目标列表（如溅射伤害、平摊伤害）
        if (tagUseSkillAttack.HurtListEx != null && tagUseSkillAttack.HurtListEx.Length > 0)
        {
            foreach (var hurtEx in tagUseSkillAttack.HurtListEx)
            {
                BattleObject exTarget = caster.battleField.battleObjMgr.GetBattleObject((int)hurtEx.ObjID);
                if (exTarget == null)
                {
                    Debug.LogError($"顶层额外目标为空 tagUseSkillAttack.HurtListEx target == null ObjId : {hurtEx.ObjID}");
                    continue;
                }

                OnHitEachTargetEx(_hitIndex, exTarget, hurtEx);
            }
        }

        HandleHint(_hitIndex, hitList);
    }

    protected void HandleHint(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
    {
        if (0 == _hitIndex)
        {
            bool needhint = false;

            for (int i = 0; i < hitList.Count; i++)
            {
                var hurt = hitList[i];

                //8-击晕
                if ((hurt.AttackTypes & (int)DamageType.Stunned) == (int)DamageType.Stunned)
                {
                    needhint = true;
                    break;
                }

                for (int j = 0; j < hurt.HurtListEx?.Length; j++)
                {
                    var hurtex = hurt.HurtListEx[j];
                    //8-击晕
                    if ((hurtex.AttackTypes & (int)ServerDamageType.Stunned) == (int)ServerDamageType.Stunned)
                    {
                        needhint = true;
                        break;
                    }
                }

                if (needhint)
                    break;
            }

            if (needhint)
            {
                DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BattleStun);
                Hint(caster, hintConfig);
            }

            for (int i = 0; i < hitList.Count; i++)
            {
                var hurt = hitList[i];

                if ((hurt.AttackTypes & (int)DamageType.BreakArmor) == (int)DamageType.BreakArmor)
                {
                    BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (battleObject != null)
                    {
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.BreakArmor);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject, 
                            BattleConst.BreakArmorEffectID, battleObject.GetRectTransform(), battleObject.Camp, 
                            battleObject.GetModelScale());
                    }
                }
                else if ((hurt.AttackTypes & (int)DamageType.Parry) == (int)DamageType.Parry)
                {
                    BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (battleObject != null)
                    {
                        DamageNumConfig hintConfig = DamageNumConfig.Get(BattleConst.Parry);
                        Hint(battleObject, hintConfig);
                        battleField.battleEffectMgr.PlayEffect(battleObject, 
                            BattleConst.ParryEffectID, battleObject.GetRectTransform(), battleObject.Camp, 
                            battleObject.GetModelScale());
                    }
                }
            }
        }
    }

    // 处理单个目标被命中:应用伤害和施法者效果
    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt, bool suckHp)
    {
        // ============ 获取临时数据(掉落、死亡等) ============
        int objID = (int)target.ObjID;
        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
        tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);

        // 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
        if (battleField != null && battleField.IsCastingSkill(target.ObjID))
        {
            deadPack = null;
        }

        // ============ 参数打包 ============
        BattleHurtParam hurtParam = BattleUtility.CalcBattleHurtParam(this, _hitIndex, target, hurt, battleDrops, deadPack, suckHp);
#if UNITY_EDITOR
        PrintHurtParamDebugInfo(hurtParam);
#endif

        // 先调用目标受伤
        DeathRecordAction recordAc = target.Hurt(hurtParam, ownRecordAction);

        if (null != recordAc)
        {
            tempDeadPackList.Remove(hurtParam.hurter.hurtObj.ObjID);
            ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAc, ownRecordAction, true);
            currentWaitingSkill.Add(recordAc);
        }
        
        // 再调用施法者吸血/反伤
        caster.OnHurtTarget(hurtParam);
    }

    // 处理额外目标被命中（HurtListEx）：溅射、弹射、平摊伤害等
    protected virtual void OnHitEachTargetEx(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurtEx hurtEx)
    {
        // ============ 获取临时数据(掉落、死亡等) ============
        int objID = (int)target.ObjID;
        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);

        tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);

        // 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
        if (battleField != null && battleField.IsCastingSkill(target.ObjID))
        {
            deadPack = null;
        }
        // ============ 参数打包（将 tagSCUseSkillHurtEx 转换为 tagSCUseSkillHurt）============
        HB427_tagSCUseSkill.tagSCUseSkillHurt hurt = new HB427_tagSCUseSkill.tagSCUseSkillHurt
        {
            ObjID = hurtEx.ObjID,
            AttackTypes = hurtEx.AttackTypes,
            HurtHP = hurtEx.HurtHP,
            HurtHPEx = hurtEx.HurtHPEx,
            CurHP = hurtEx.CurHP,
            CurHPEx = hurtEx.CurHPEx,
            SuckHP = 0,//hurtEx.SuckHP, 获取全部吸血时已经计算过 这里就不再计算
            BounceHP = 0, // HurtEx 没有反伤字段
            HurtCountEx = 0,
            HurtListEx = null
        };

        OnHitEachTarget(_hitIndex, target, hurt, false);//获取全部吸血时已经计算过 这里就不再计算
    }

#if UNITY_EDITOR
    private void PrintHurtParamDebugInfo(BattleHurtParam hurtParam)
    {
        bool isLastHit = hurtParam.hitIndex >= hurtParam.skillSkinConfig.DamageDivide.Length - 1;
        
        long currentHitDamage = hurtParam.hurter.damageList != null ? hurtParam.hurter.damageList.Sum() : 0;
        long currentHitSuckHp = hurtParam.caster.suckHpList != null ? hurtParam.caster.suckHpList.Sum() : 0;
        long currentHitReflectHp = hurtParam.caster.reflectHpList != null ? hurtParam.caster.reflectHpList.Sum() : 0;
        
        long totalDamage = GeneralDefine.GetFactValue(hurtParam.hurt.HurtHP, hurtParam.hurt.HurtHPEx);
        long totalSuckHp = BattleUtility.GetSuckHp(tagUseSkillAttack);
        long totalReflectHp = hurtParam.hurt.BounceHP;
        
        BattleDebug.LogError(
            (hurtParam.caster.casterObj.Camp == BattleCamp.Red ? "【红方行动】" : "【蓝方行动】 ") +
            $"攻击者: {hurtParam.caster.casterObj.GetName()} (ObjID:{hurtParam.caster.casterObj.ObjID})\n" +
            $"目标: {hurtParam.hurter.hurtObj.GetName()} (ObjID:{hurtParam.hurter.hurtObj.ObjID})\n" +
            $"技能: {hurtParam.skillConfig.SkillName} (ID:{hurtParam.skillConfig.SkillID})\n" +
            $"击数: 第{hurtParam.hitIndex + 1}击 / 共{hurtParam.skillSkinConfig.DamageDivide.Length}击" + (isLastHit ? " [最后一击]" : " [中间击]") + "\n" +
            $"\n" +
            $"========== 目标受伤数据 ==========\n" +
            $"伤害: {currentHitDamage} / 总伤害: {totalDamage}\n" +
            $"伤害分段: [{string.Join(", ", hurtParam.hurter.damageList ?? new List<long>())}]\n" +
            $"目标血量: {hurtParam.hurter.fromHp} -> {hurtParam.hurter.toHp} (最大:{hurtParam.hurter.maxHp})\n" +
            $"目标护盾: {hurtParam.hurter.fromShieldValue} -> {hurtParam.hurter.toShieldValue}\n" +
            $"攻击类型: {hurtParam.hurt.AttackTypes}\n" +
            $"\n" +
            $"========== 施法者数据 ==========\n" +
            $"吸血: {currentHitSuckHp} / 总吸血: {totalSuckHp}\n" +
            $"吸血分段: [{string.Join(", ", hurtParam.caster.suckHpList ?? new List<long>())}]\n" +
            $"反伤: {currentHitReflectHp} / 总反伤: {totalReflectHp}\n" +
            $"反伤分段: [{string.Join(", ", hurtParam.caster.reflectHpList ?? new List<long>())}]\n" +
            $"施法者血量: {hurtParam.caster.fromHp} -> {hurtParam.caster.toHp} (最大:{hurtParam.caster.maxHp})\n" +
            $"施法者护盾: {hurtParam.caster.fromShieldValue} -> {hurtParam.caster.toShieldValue}\n"
        );
    }
#endif

    // 处理HP刷新包（简化逻辑）
    private void HandleRefreshHP()
    {
        // 查找HP刷新包
        HB419_tagSCObjHPRefresh refreshPack = BattleUtility.FindObjHPRefreshPack(packList);

        if (refreshPack != null)
        {
            // 分发HP刷新包
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：HP刷新包是技能内部产生的，应该由当前SkillRecordAction的innerRecordPlayer管理
            // 这样可以确保HP刷新与技能的生命周期绑定，ForceFinish时一并处理
            PackageRegeditEx.DistributeToRecordAction(refreshPack, ownRecordAction);
            packList.Remove(refreshPack);
        }
    }

    // 处理死亡相关逻辑：分配掉落和经验
    protected void HandleDead()
    {
        List<BattleDeadPack> deadPackList = BattleUtility.FindDeadPack(packList);
        if (deadPackList.Count <= 0) return;

        foreach (var deadPack in deadPackList)
        {
            packList.Remove(deadPack.deadPack);
            packList.Remove(deadPack.deadTriggerSkill);
        }

        // 找到最大的死亡包 packUID
        BattleDeadPack lastBattleDeadPack = null;
        ulong maxDeathPackUID = 0;
        foreach (var deadPack in deadPackList)
        {
            if (deadPack.deadPack != null && deadPack.deadPack.packUID > maxDeathPackUID)
            {
                maxDeathPackUID = deadPack.deadPack.packUID;
                lastBattleDeadPack = deadPack;
            }
        }
        
        // 如果找到了死亡包，收集所有 packUID > maxDeathPackUID 的包
        if (maxDeathPackUID > 0 && lastBattleDeadPack != null)
        {
            BattleDebug.LogError($"SkillBase.HandleDead: 找到死亡包，maxDeathPackUID = {maxDeathPackUID}，开始收集死亡后的包");
            
            // 1. 收集 packList 中 packUID 大于死亡包的包（排除经验包和掉落包，它们需要在当前技能中处理）
            List<GameNetPackBasic> packsToRemove = new List<GameNetPackBasic>();
            foreach (var pack in packList)
            {
                ulong packUID = GetPackUID(pack);
                if (packUID > maxDeathPackUID)
                {
                    // 排除经验包和掉落包，它们属于当前死亡事件的一部分，不是"死亡后"的包
                    if (pack is HB405_tagMCAddExp expPack && expPack.Source == 2 || 
                        (pack is H0704_tagRolePackRefresh h0704 && h0704.PackType == (byte)PackType.DropItem && h0704.IsBind == 1))
                    {
                        continue; // 跳过经验包和掉落包，让 CheckAfterDeadhPack() 处理它们
                    }
                    
                    BattleDebug.LogError($"SkillBase.HandleDead: 从packList收集死亡后的包 - Type: {pack.GetType().Name}, UID: {packUID}");
                    lastBattleDeadPack.packListAfterDeath.Add(pack);
                    packsToRemove.Add(pack);
                }
            }

            packList.RemoveAll(p => packsToRemove.Contains(p));
        }

        CheckAfterDeadhPack();

        // 修复：先收集要删除的包，避免在foreach中修改集合
        var dropPacksToRemove = new List<H0704_tagRolePackRefresh>(dropPackList);
        foreach (var _dropPack in dropPacksToRemove)
        {
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：掉落包是技能效果的一部分，应该由当前SkillRecordAction管理
            // 掉落包的分发与技能完成绑定，确保在技能ForceFinish时正确处理
            PackageRegeditEx.DistributeToRecordAction(_dropPack, ownRecordAction);
            packList.Remove(_dropPack);
        }

        // 获取并分配掉落物品和经验
        var dropPack = PackManager.Instance.GetSinglePack(PackType.DropItem);
        var itemDict = dropPack.GetAllItems();
        List<ItemModel> itemList = new List<ItemModel>(itemDict.Values.Where(item => item != null && item.isAuction));

        var dropAssign = AssignDrops(itemList, deadPackList.Count);
        var expAssign = AssignExp(expPackList, deadPackList.Count);

        // 构造BattleDrops并缓存
        for (int i = 0; i < deadPackList.Count; i++)
        {
            BattleDeadPack bdp = deadPackList[i];
            int objID = (int)bdp.deadPack.ObjID;
            BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject(objID);
            
            // 修复：添加空值检查
            if (deadTarget == null)
            {
                Debug.LogError($"找不到死亡目标，ObjID: {objID}");
                continue;
            }
            
            List<int> itemIndexList = dropAssign[i].Select(item => item.gridIndex).ToList();
            
            BattleDrops battleDrops = new BattleDrops()
            {
                rectTransform = deadTarget.GetRectTransform(),
                dropItemPackIndex = itemIndexList,
                expDrops = expAssign[i]
            };

            // 修复：避免字典键冲突，使用安全的添加方式
            if (!tempDropList.ContainsKey(objID))
            {
                tempDropList.Add(objID, battleDrops);
            }
            else
            {
                Debug.LogWarning($"tempDropList中已存在ObjID={objID}的记录，将覆盖原值");
                tempDropList[objID] = battleDrops; // 覆盖现有值
            }

            if (!tempDeadPackList.ContainsKey(objID))
            {
                tempDeadPackList.Add(objID, deadPackList[i]);
            }
            else
            {
                Debug.LogWarning($"tempDeadPackList中已存在ObjID={objID}的记录，将覆盖原值");
                tempDeadPackList[objID] = deadPackList[i]; // 覆盖现有值
            }
        }

        // 修复：避免在遍历时修改集合，先收集后删除
        var deadPacksToRemove = new List<GameNetPackBasic>(deadPackList.Select(d => d.deadPack));
        deadPacksToRemove.AddRange(deadPackList.Where(d => d.deadTriggerSkill != null).Select(d => d.deadTriggerSkill));
        foreach (var deadPack in deadPacksToRemove)
        {
            packList.Remove(deadPack);
        }
    }

    // 分配掉落物品：将掉落物品平均分配给死亡对象
    protected List<List<ItemModel>> AssignDrops(List<ItemModel> itemList, int deadCount)
    {
        var dropAssign = new List<List<ItemModel>>();
        for (int i = 0; i < deadCount; i++)
            dropAssign.Add(new List<ItemModel>());
        for (int i = 0; i < itemList.Count; i++)
            dropAssign[i % deadCount].Add(itemList[i]);
        return dropAssign;
    }

    // 获取包的 packUID
    protected ulong GetPackUID(GameNetPackBasic pack)
    {
        if (pack == null) return 0;
        
        if (pack is HB422_tagMCTurnFightObjDead deadPack)
            return deadPack.packUID;
        
        if (pack is CustomHB426CombinePack combinePack)
        {
            var mainSkillPack = combinePack.GetMainHB427SkillPack();
            return mainSkillPack?.packUID ?? 0;
        }
        
        if (pack is HB427_tagSCUseSkill skillPack)
            return skillPack.packUID;
        
        if (pack is HB428_tagSCBuffRefresh buffRefresh)
            return buffRefresh.packUID;
        
        if (pack is HB429_tagSCBuffDel buffDel)
            return buffDel.packUID;
        
        if (pack is HB419_tagSCObjHPRefresh hpRefresh)
            return hpRefresh.packUID;
        
        if (pack is HB405_tagMCAddExp expPack)
            return expPack.packUID;
        
        if (pack is H0704_tagRolePackRefresh dropPack)
            return dropPack.packUID;
        
        // 尝试通过反射获取 packUID
        var packUIDField = pack.GetType().GetField("packUID");
        if (packUIDField != null)
        {
            return (ulong)packUIDField.GetValue(pack);
        }
        
        return 0;
    }

    // 分配经验值：将经验包平均分配给每个死亡对象
    protected List<List<HB405_tagMCAddExp>> AssignExp(List<HB405_tagMCAddExp> expList, int deadCount)
    {
        var expAssign = new List<List<HB405_tagMCAddExp>>();
        for (int i = 0; i < deadCount; i++)
            expAssign.Add(new List<HB405_tagMCAddExp>());

        // 修复：检查除零风险
        if (deadCount == 0)
        {
            Debug.LogWarning("AssignExp: deadCount为0，无法分配经验");
            return expAssign;
        }

        // 修复：先收集要删除的包，避免在foreach中修改packList
        var expPacksToRemove = new List<HB405_tagMCAddExp>();

        foreach (var expPack in expList)
        {
            long totalExp = GeneralDefine.GetFactValue(expPack.Exp, expPack.ExpPoint);
            long avgExp = totalExp / deadCount;
            long remain = totalExp % deadCount;

            for (int i = 0; i < deadCount; i++)
            {
                long assignExp = avgExp + (i < remain ? 1 : 0);
                var newPack = new HB405_tagMCAddExp
                {
                    Exp = (uint)(assignExp % Constants.ExpPointValue),
                    ExpPoint = (uint)(assignExp / Constants.ExpPointValue),
                    Source = expPack.Source
                };
                expAssign[i].Add(newPack);
            }
            expPacksToRemove.Add(expPack);
        }
        
        // 统一删除收集的包
        foreach (var pack in expPacksToRemove)
        {
            packList.Remove(pack);
        }

        return expAssign;
    }

    // 检查死亡后的包处理：处理技能包、掉落包、经验包
    protected void CheckAfterDeadhPack()
    {
        List<int> removeIndexList = new List<int>();
        
        for (int i = 0; i < packList.Count; i++)
        {
            var pack = packList[i];

            // 复活基本都靠技能包
            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
                break;
                
            if (pack is H0704_tagRolePackRefresh h0704Pack && h0704Pack.PackType == (byte)PackType.DropItem && h0704Pack.IsBind == 1)
            {
                dropPackList.Add(h0704Pack);
                removeIndexList.Add(i);
            }
            
            if (pack is HB405_tagMCAddExp h405Pack && h405Pack.Source == 2)
            {
                expPackList.Add(h405Pack);
                removeIndexList.Add(i);
            }
        }

        for (int i = removeIndexList.Count - 1; i >= 0; i--)
            packList.RemoveAt(removeIndexList[i]);
    }


    public virtual bool IsActionCompleted()
    {
        if (!isPlay) return false;

        if (skillEffect != null)
        {
            if (!skillEffect.IsFinished()) return false;
        }

        if (moveFinished)
        {
            //  如果技能有动画（SkillMotionName不为空），需要等待动画播放完成
            if (skillSkinConfig != null && !string.IsNullOrEmpty(skillSkinConfig.SkillMotionName))
            {
                if (!isMotionCompleted)
                {
                    BattleDebug.LogError($"SkillBase.IsActionCompleted: 技能 {skillConfig.SkillID} 等待动画播放完成");
                    return false;
                }
            }

            return true;
        }

        return false;
    }

    // 检查技能是否完成：综合检查所有完成条件
    public virtual bool IsFinished()
    {
        if (!isPlay) return false;
        
        bool tempRetValue = true;

        // 检查技能效果是否完成
        if (skillEffect != null)
        {
            if (!skillEffect.IsFinished()) return false;
            skillEffect = null;
            OnSkillFinished();
            tempRetValue = false;
        }

        // 检查其他技能动作是否完成
        if (currentWaitingSkill.Count > 0)
        {
            if (currentWaitingSkill.Any(s => s.IsFinished()))
            {
                currentWaitingSkill.RemoveAll(s => s.IsFinished());
                OnSkillFinished();
            }
            else
            {
                tempRetValue = false;
            }
        }

        if (!tempRetValue)
        {
            return false;
        }


        // 检查最终完成状态
        if (isFinished && moveFinished)
        {
            if (packList.Count > 0)
            {
                OnSkillFinished();
                return false;
            }

            //  如果自己内部的recora action的 inner record player还有没执行完的包 也是返回false
            if (ownRecordAction != null && ownRecordAction.GetInnerRecordPlayer().IsPlaying())
            {
                return false;
            }

            // 技能完全结束，移除技能注册并触发延迟的死亡判定
            if (battleField != null && caster != null)
            {
                battleField.RemoveCastingSkill(caster.ObjID, this);
                
                //  传递parentRecordAction，让死亡技能等待当前技能完成
                DeathRecordAction recordAction = battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values), null, ownRecordAction);
                if (null != recordAction)
                {
                    ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(recordAction);
                    tempDeadPackList.Clear();
                    return false;
                }
            }

            return !ownRecordAction.GetInnerRecordPlayer().IsPlaying();
        }

        return false;
    }


    // 强制结束技能：立即结束所有技能相关的处理
    public virtual void ForceFinished()
    {
        if (isFinished)
            return;

        // 移除技能注册
        if (battleField != null && caster != null)
        {
            battleField.RemoveCastingSkill(caster.ObjID, this);
        }

        //  传递parentRecordAction，让死亡技能等待当前技能完成
        RecordAction rc = battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values));
        if (null != rc)
        {
            ownRecordAction.GetInnerRecordPlayer().ImmediatelyPlay(rc);
        }
        tempDeadPackList.Clear();

        // 1. 强制结束技能效果
        skillEffect?.ForceFinished();
        skillEffect = null;
        
        // 2. 强制结束所有子技能动作
        if (currentWaitingSkill.Count > 0)
        {
            foreach (var skill in currentWaitingSkill)
            {
                skill.ForceFinish();
            }
            currentWaitingSkill.Clear();
        }

        // 3. 清理 DOTween 动画（防止移动回调在战斗结束后执行）
        if (caster != null)
        {
            caster.StopMoveAnimation();
        }

        // 4. 重置施法者状态
        if (caster != null)
        {
            // 重置位置到原点
            caster.ResetPosition();
            
            // 重置朝向
            caster.ResetFacing();

            // 取消幻影效果
            caster.ShowIllusionShadow(false);
        }

        // 5. 恢复 UI 状态
        if (battleField != null)
        {
            // 恢复所有角色的显示层级和血条
            var allList = battleField.battleObjMgr?.allBattleObjDict?.Values;
            if (allList != null)
            {
                foreach (BattleObject bo in allList)
                {
                    bo.layerMgr?.SetFront();
                    bo.GetHeroInfoBar()?.SetActive(true);
                }
            }
            
            // 关闭技能遮罩
            if (battleField.battleRootNode != null && battleField.battleRootNode.skillMaskNode != null)
            {
                battleField.battleRootNode.skillMaskNode.SetActive(false);
            }
        }

        isFinished = true;
        moveFinished = true;
        isPlay = true;
        
        //  强制结束时，无论是否有动画，都标记动画完成
        isMotionCompleted = true;

        // 6. 处理所有剩余包（包括 buff 包）
        // 先处理 buffPackCollections
        DistributeBuffPacks(buffPackCollections);
        buffPackCollections.Clear();

        // 处理剩余的 packList
        while (packList.Count > 0)
        {
            var pack = packList[0];
            packList.RemoveAt(0);

            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                var otherSkillAction = combinePack.CreateSkillAction();
                otherSkillAction.fromSkill = this;
                otherSkillAction.ForceFinish();
            }
            else
            {
                // 【使用 parentRecordAction.innerRecordPlayer】
                // 原因：ForceFinished时剩余的包也是技能内部产生的，应该由innerRecordPlayer管理
                // 这样可以确保即使强制结束，包的处理也在正确的上下文中
                PackageRegedit.Distribute(pack);
            }
        }
    }

    // 技能完成处理：正常完成时的清理工作
    public void OnSkillFinished()
    {
        // 修复：使用循环代替递归，避免栈溢出风险
        // try
        // {
        while (true)
        {
            // 验证技能效果是否完成
            if (skillEffect != null && !skillEffect.IsFinished())
                return;

            if (skillEffect != null)
            {
                skillEffect = null;
                continue; // 使用continue代替递归调用
            }

            // 验证其他技能动作是否完成
            if (currentWaitingSkill.Count > 0)
            {
                bool hasFinishedAction = currentWaitingSkill.All(s => s.IsFinished());

                if (hasFinishedAction)
                {
                    // 修复死循环：完成后需要清空 currentWaitingSkill
                    currentWaitingSkill.Clear();
                    continue; // 使用continue代替递归调用
                }
                return;
            }

            break; // 没有更多需要处理的，退出循环
        }

        // 处理剩余包
        if (!ResolvePackList())
        {
            return;
        }
            // }
            // catch (Exception ex)
            // {
            //     Debug.LogError($"OnSkillFinished异常: {ex.Message}，技能ID={skillConfig.SkillID}");
            //     // 确保状态一致性，即使出现异常也要标记完成
            //     isFinished = true;
            //     throw; // 重新抛出异常供上层处理
            // }

        isFinished = true;
    }
    
    protected virtual bool ResolvePackList()
    {
        if (currentWaitingSkill.Count > 0)
        {
            return false;
        }

        while (packList.Count > 0)
        {
            var pack = packList[0];
            packList.RemoveAt(0);


            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                var skillRecordAction = combinePack.CreateSkillAction();
                skillRecordAction.fromSkill = this;
                currentWaitingSkill.Add(skillRecordAction);

                //  需要给真正parent播的
                if (skillRecordAction.useParentRecordPlayer && skillRecordAction.parentSkillAction != null)
                {
                    skillRecordAction.parentSkillAction.GetInnerRecordPlayer().PlayRecord(skillRecordAction);
                }
                else
                {
                    ownRecordAction.GetInnerRecordPlayer().PlayRecord(skillRecordAction);
                }

                return false;
            }
            else if (IsBuffPack(pack))
            {
                // 从找到第一个 Buff 包开始，收集连续的 HB428/HB429 包
                buffPackCollections.Add(pack);
                while (packList.Count > 0)
                {
                    var nextPack = packList[0];
                    if (IsBuffPack(nextPack))
                    {
                        buffPackCollections.Add(nextPack);
                        packList.RemoveAt(0);
                    }
                    else
                    {
                        break;
                    }
                }

                // 处理所有收集到的 buff 包
                ProcessBuffPacks(buffPackCollections);

                // 清空已处理的 buff 集合
                buffPackCollections.Clear();
                continue;
            }
            else
            {
                // 【使用 parentRecordAction.innerRecordPlayer】
                // 原因：技能执行过程中的包（Buff、属性刷新等）是技能效果的一部分
                // 应该由SkillRecordAction的innerRecordPlayer管理，确保与技能生命周期一致
                PackageRegeditEx.DistributeToRecordAction(pack, ownRecordAction);
            }
        }

        return true;
    }

    // 添加清理方法：防止内存泄漏
    public virtual void Cleanup()
    {
        tempDropList?.Clear();
        tempDeadPackList?.Clear();
        currentWaitingSkill?.Clear();
        dropPackList?.Clear();
        expPackList?.Clear();
        buffPackCollections?.Clear();
        
        skillEffect = null;
        packList = null;
    }

    #region Buff包处理

    /// <summary>
    /// 判断是否为 Buff 相关的包（HB428 或 HB429）
    /// </summary>
    protected bool IsBuffPack(GameNetPackBasic pack)
    {
        return pack is HB428_tagSCBuffRefresh || pack is HB429_tagSCBuffDel;
    }

    /// <summary>
    /// 处理收集到的 Buff 包列表（HB428 刷新 和 HB429 删除）
    /// </summary>
    protected void ProcessBuffPacks(List<GameNetPackBasic> buffPacks)
    {
        if (buffPacks == null || buffPacks.Count == 0) return;

        foreach (var pack in buffPacks)
        {
            if (pack is HB428_tagSCBuffRefresh buffRefresh)
            {
                BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffRefresh.ObjID);
                if (battleObj != null)
                {
                    var buffMgr = battleObj.GetBuffMgr();
                    if (buffMgr != null) // 命格不有 buff 管理器
                    {
                        buffMgr.RefreshBuff(buffRefresh, true);
                    }
                }
            }
            else if (pack is HB429_tagSCBuffDel buffDel)
            {
                BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffDel.ObjID);
                if (battleObj != null)
                {
                    var buffMgr = battleObj.GetBuffMgr();
                    if (buffMgr != null) // 命格不有 buff 管理器
                    {
                        buffMgr.RemoveBuff(buffDel, false);
                    }
                }
            }
        }
    }

    /// <summary>
    /// 强制分发 Buff 包（用于 ForceFinished 场景）
    /// </summary>
    protected void DistributeBuffPacks(List<GameNetPackBasic> buffPacks)
    {
        if (buffPacks == null || buffPacks.Count == 0) return;

        foreach (var pack in buffPacks)
        {
            // 【使用 parentRecordAction.innerRecordPlayer】
            // 原因：Buff包是技能效果的核心组成部分，应该由SkillRecordAction管理
            // 即使是强制分发的情况，也要保持在正确的RecordAction上下文中
            PackageRegeditEx.DistributeToRecordAction(pack, ownRecordAction);
        }
    }

    public virtual bool CanStartExecution()
    {
        if (null == caster)
        {
            return false;
        }

        if (null == skillConfig)
        {
            return false;
        }

        if (string.IsNullOrEmpty(skillSkinConfig.SkillMotionName))
        {
            return true;
        }

        return !battleField.IsCastingSkill(caster.ObjID);
    }

    #endregion

}

 Main/System/Battle/SkillEffect/SkillEffect.cs

@@ -78,6 +78,14 @@
        return isFinish && isFinishFrameEnd;
    }

#if UNITY_EDITOR
    /// <summary>卡死诊断用：打印 SkillEffect 内部 isFinish / isFinishFrameEnd 等标志位。</summary>
    public virtual string DumpState()
    {
        return $"{GetType().Name} isFinish={isFinish} isFinishFrameEnd={isFinishFrameEnd}";
    }
#endif

    public virtual void ForceFinished()
    {
        isFinish = true;