512 跨服演武场

lcy

4 天以前 2dd1841d03a730d3d369092c2a3ad656cee4bf64

 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,41 +26,252 @@
                                                        87f / 255f,
                                                        189f / 255f);

    protected SkillEffect skillEffect;
    protected HB427_tagSCUseSkill tagUseSkillAttack;
    // ===== 核心引用 =====
    public HB427_tagSCUseSkill tagUseSkillAttack;
    public SkillConfig skillConfig;
    protected bool isFinished = false;
    public SkillSkinConfig skillSkinConfig;
    public BattleObject caster = null; // 施法者
    protected BattleField battleField = null; // 战场
    protected RectTransform targetNode = null; // 目标节点
    protected BattleObject caster = null; // 施法者
    protected List<GameNetPackBasic> packList;
    protected List<SkillRecordAction> otherSkillActionList = new List<SkillRecordAction>();

    // ===== 命中效果 =====
    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 int fromSkillId;
    public bool isPlay = false;
    private Dictionary<int, BattleDrops> tempDropList = new Dictionary<int, BattleDrops>();
    private Dictionary<int, BattleDeadPack> tempDeadPackList = new Dictionary<int, BattleDeadPack>();

    // ===== 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;

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

    protected List<HB428_tagSCBuffRefresh> buffCollections = new List<HB428_tagSCBuffRefresh>();

#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)
    {
        caster = _caster;
        if (null == caster)
        {
            throw new Exception("SkillBase caster is null ");
        }
        skillConfig = _skillCfg;
        tagUseSkillAttack = vNetData;
        battleField = _battleField;
        packList = _packList;

        if (_caster is HeroBattleObject heroBattleObject)
        {
            skillSkinConfig = skillConfig.GetSkillSkinConfig(heroBattleObject.teamHero.SkinID);

            if (null == skillSkinConfig)
            {
                Debug.LogError("找不到技能皮肤表 " + "skillId: " + skillConfig.SkillID + " skinId: " + heroBattleObject.teamHero.SkinID);
            }
        }
        else
        {
            skillSkinConfig = skillConfig.GetOriginSkinConfig();
        }


        // 注册正在释放的技能
        if (battleField != null && caster != null)
        {
            battleField.AddCastingSkill(caster.ObjID, this);
        }

        SafetyCheck();
    }

    public virtual void AfterAddToQueue()
    {

    }

    //  设置父RecordAction
    public void SetOwnRecordAction(SkillRecordAction recordAction)
    {
        ownRecordAction = recordAction;
    }

    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";
                for (int j = 0; j < Hurt.HurtListEx.Length; j++)
                {
                    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";
                }
            }
        }

        skillDetail += "------------------ HurtListEx ------------------\n";
        if (tagUseSkillAttack.HurtListEx != null)
        {
            for (int i = 0; i < tagUseSkillAttack.HurtListEx.Length; i++)
            {
                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";
                skillDetail += $"      SuckHP: {HurtEx.SuckHP}\n";
                skillDetail += $"      AttackTypes: {HurtEx.AttackTypes}\n";
            }
        }

        skillDetail += "------------------ END ------------------\n";

        if (changeListDict.ContainsKey(caster.battleField.guid))
        {
            string origin = changeListDict[caster.battleField.guid];
            origin += skillDetail;
            changeListDict[caster.battleField.guid] = origin;

        }
        else
            changeListDict.Add(caster.battleField.guid, skillDetail);

        Debug.LogError("skillDetail : " + skillDetail);
#endif
    }

    private void SafetyCheck()
    {
#if UNITY_EDITOR
        if (Launch.Instance.isOpenSkillLogFile)
        {
            PinrtHB427Hp();
        }
#endif

        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();
        }
    }

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

        if (otherSkillActionList.Count > 0)
        {
            for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
            {
                var action = otherSkillActionList[i];
                if (action.IsFinished())
                {
                    otherSkillActionList.RemoveAt(i);
                    OnSkillFinished();
                }
                else if (moveFinished)
                {
                    action.Run();
                }
            }
        }
    }

    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.motionBase.ShowIllusionShadow(true, color);
            }
        }
        else
        {
            MoveSpeed = 750f;
            caster.motionBase.ShowIllusionShadow(false);
        }
    }

    // 技能释放主逻辑：广播事件、高亮目标、执行释放
    public virtual void Cast()
    {
        // 广播技能释放事件
        string guid = battleField.guid;
        TeamHero teamHero = caster.teamHero;
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);

        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);
            }
            
            if (hintConfig != null)
            {
                caster.heroInfoBar.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
                // Debug.Break();
            }
        }

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

        // 根据释放模式执行相应逻辑
        switch (skillConfig.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 " + skillConfig.CastPosition);
                ForceFinished();
                break;
        }
    }

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

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

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

        int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(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.teamHero.positionNum);
            // ShadowIllutionCreate(true);
            MoveToTarget(rectTransform, Vector2.zero, () =>
            {
                // ShadowIllutionCreate(false);
                OnAttackFinish();
            }, MoveSpeed);
        });
    }

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

    // 执行移动-施法-返回序列：通用的移动攻击流程
    private void ExecuteMoveAndCastSequence(RectTransform target, Action onReturnComplete)
    {
        ShadowIllutionCreate(true);
        MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
        {
            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 (skillConfig.CastDistance >= 9999)
        {
            _onComplete?.Invoke();
            return;
        }

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

    // 转身逻辑：根据技能配置处理角色转向
    protected void TurnBack(Action _onComplete, float forward)
    {
        if (skillConfig.CastDistance < 0)
        {
            Vector3 scale = caster.heroGo.transform.localScale;
            scale.x = Mathf.Abs(scale.x) * forward;
            caster.heroGo.transform.localScale = scale;
        }
        _onComplete?.Invoke();
    }

    // 攻击完成后的处理：转身、恢复状态、播放待机动画
    protected void OnAttackFinish()
    {
        TurnBack(null, 1f);
        OnAllAttackMoveFinished();
        caster.motionBase.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.heroInfoBar.SetActive(true);
        }
        battleField.battleRootNode.skillMaskNode.SetActive(false);
    }

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

    // 技能开始回调：处理死亡、子技能、技能效果初始化
    public void OnSkillStart()
    {
        HandleDead();
        
        skillEffect = SkillEffectFactory.CreateSkillEffect(caster, skillConfig, tagUseSkillAttack);
        skillEffect.Play(OnHitTargets);
        foreach (var subSkillPack in tagUseSkillAttack.subSkillList)
        if (isPlay)
        {
            SkillRecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic>() { subSkillPack });
            otherSkillActionList.Add(recordAction);
            battleField.recordPlayer.ImmediatelyPlay(recordAction);
            Debug.LogError(" play twice OnSkillStart skillId :" + skillConfig.SkillID);
            return;
        }

        //  先把死亡包收集了
        HandleDead();

        //  再处理 内嵌技能
        ProcessSubSkill();

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


        isPlay = true;
    }

    // ===== 技能节拍回调 =====

    // 技能前摇结束回调
    public virtual void OnStartSkillFrameEnd() { }
@@ -375,564 +340,10 @@
    // 技能后摇结束回调：通知技能效果处理后摇结束
    public virtual void OnFinalFrameEnd()
    {
        
        //  标记动画播放完成
        isMotionCompleted = true;
        BattleDebug.LogError($"SkillBase.OnFinalFrameEnd: 技能 {skillConfig?.SkillID} 动画播放完成");

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

    // 高亮所有相关目标：设置施法者和目标的显示层级
    protected void HighLightAllTargets()
    {
        caster.layerMgr.SetSortingOrder(BattleConst.ActiveHeroActionSortingOrder);

        if (skillConfig.FuncType != 2)
            return;

        List<BattleObject> targetList = battleField.battleObjMgr.GetBattleObjList(tagUseSkillAttack);
        List<BattleObject> highlightList = new List<BattleObject>(targetList) { caster };
        List<BattleObject> allList = battleField.battleObjMgr.allBattleObjDict.Values.ToList<BattleObject>();
        
        // 修复：使用HashSet优化性能，避免重复设置
        var targetSet = new HashSet<BattleObject>(targetList);
        var highlightSet = new HashSet<BattleObject>(highlightList);
        
        caster.heroInfoBar.SetActive(false);

        foreach (BattleObject bo in allList)
        {
            bool isHighlight = highlightSet.Contains(bo);
            bool isTarget = targetSet.Contains(bo);
            
            if (isHighlight)
            {
                bo.layerMgr.SetFront();
            }
            else
            {
                bo.layerMgr.SetBack();
            }

            bo.heroInfoBar.SetActive(isTarget);
        }

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

    // 命中目标回调：处理所有被命中的目标
    protected virtual void OnHitTargets(int _hitIndex, List<HB427_tagSCUseSkill.tagSCUseSkillHurt> hitList)
    {
        //  造成伤害前先处理血量刷新包
        HandleRefreshHP();

        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);
        }
    }

    // 处理单个目标被命中:应用伤害和施法者效果
    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt)
    {
        // ============ 第一步:计算伤害分布 ============
        List<int> damageDivide = new List<int>();
        if (_hitIndex == 0 && skillConfig.DamageDivide.Length <= 0)
        {
            damageDivide.Add(10000);
        }
        else
        {
            if (skillConfig.DamageDivide.Length <= _hitIndex)
            {
                Debug.LogError("技能伤害分布配置错误 skillId: " + skillConfig.SkillID + " hitIndex: " + _hitIndex);
                damageDivide.Add(10000);
            }
            else
            {
                damageDivide = skillConfig.DamageDivide[_hitIndex].ToList();
            }
        }

        // 计算总伤害和分段伤害列表
        long totalDamage = GeneralDefine.GetFactValue(hurt.HurtHP, hurt.HurtHPEx);
        List<long> damageList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, totalDamage);

        // ============ 第二步:刷新实际血量 ============
        long fromHp = target.teamHero.curHp;
        


        // ============处理吸血跟反伤 ===============
        //  也要按每一击平均算 最后要补齐伤害
        long suckHp = hurt.SuckHP;
        long reflectHp = hurt.BounceHP;

        List<long> suckHpList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, suckHp);

        List<long> reflectHpList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, hurt.BounceHP);
        // long currentSuckHp = suckHp / tagUseSkillAttack.HurtCount;

        // 计算当前这一击的实际伤害(所有分段伤害之和)
        long currentHitDamage = 0;
        foreach (long dmg in damageList)
        {
            currentHitDamage += dmg;
        }

        long currentHitSuckHp = 0;
        foreach (long suck in suckHpList)
        {
            currentHitSuckHp += suck;
        }

        long currentHitReflectHp = 0;
        foreach (long reflect in reflectHpList)
        {
            currentHitReflectHp += reflect;
        }

        long toHp = Math.Max(0, fromHp - currentHitDamage + currentHitSuckHp - currentHitReflectHp);


        // 更新目标血量
        target.teamHero.curHp = toHp;

#if UNITY_EDITOR
        BattleDebug.LogError(
            (caster.Camp == BattleCamp.Red ? "【红方行动】" : "【蓝方行动】") + "\n" +
            $"攻击者: {caster.teamHero.name}\n" +
            $"目标: {target.teamHero.name}\n" +
            $"技能: {skillConfig.SkillName} (第{_hitIndex}击)\n" +
            $"伤害: {currentHitDamage} (总伤害: {totalDamage})\n" +
            $"吸血: {currentHitSuckHp}\n" +
            $"反伤: {currentHitReflectHp}\n" +
            $"血量变化: {fromHp} -> {toHp}"
        );
#endif

        
        bool isLastHit = _hitIndex >= skillConfig.DamageDivide.Length - 1;

        // ============ 第三步:获取临时数据(掉落、死亡等) ============
        int objID = (int)target.ObjID;
        tempDropList.TryGetValue(objID, out BattleDrops battleDrops);
        tempDeadPackList.TryGetValue(objID, out HB422_tagMCTurnFightObjDead deadPack);


        //  参数打包
        BattleHurtParam hurtParam = new BattleHurtParam()
        {
            casterObj = caster,
            hurtObj = target,
            damageList = damageList,
            suckHpList = suckHpList,
            reflectHpList = reflectHpList,
            fromHp = fromHp,
            toHp = toHp,
            battleDrops = battleDrops,
            hurt = hurt,
            hitIndex = _hitIndex,
            deadPack = deadPack,
            skillConfig = skillConfig
        };

        // ============ 第四步:执行表现(飘字、动画等) ============
        target.Hurt(hurtParam);


    }

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

        if (refreshPack != null)
        {
            // 分发HP刷新包
            PackageRegedit.Distribute(refreshPack);
            packList.Remove(refreshPack);
        }
    }

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

        CheckAfterDeadhPack();

        // 修复：先收集要删除的包，避免在foreach中修改集合
        var dropPacksToRemove = new List<H0704_tagRolePackRefresh>(dropPackList);
        foreach (var _dropPack in dropPacksToRemove)
        {
            PackageRegedit.Distribute(_dropPack);
            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++)
        {
            int objID = (int)deadPackList[i].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.heroRectTrans,
                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.Cast<GameNetPackBasic>());
        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;
    }

    // 分配经验值：将经验包平均分配给每个死亡对象
    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 IsFinished()
    {
        if (!isPlay) return false;
        

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

        // 检查其他技能动作是否完成
        if (otherSkillActionList.Count > 0)
        {
            for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
            {
                var action = otherSkillActionList[i];
                if (action.IsFinished())
                {
                    otherSkillActionList.RemoveAt(i);
                    OnSkillFinished();
                }
            }
            if (otherSkillActionList.Count > 0) return false;
        }

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

            return true;
        }

        return false;
    }


    // 强制结束技能：立即结束所有技能相关的处理
    public virtual void ForceFinished()
    {
        skillEffect?.ForceFinished();
        
        otherSkillActionList.ForEach(action => action.ForceFinish());
        otherSkillActionList.Clear();

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

        // 处理所有剩余包
        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.fromSkillId = skillConfig.SkillID;
                otherSkillAction.ForceFinish();
            }
            else
            {
                if (pack is CustomB421ActionPack actionPack)
                    actionPack.Distribute();
                PackageRegedit.Distribute(pack);
            }
        }
    }

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

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

            // 验证其他技能动作是否完成
            if (otherSkillActionList.Count > 0)
            {
                bool hasFinishedAction = false;
                for (int i = otherSkillActionList.Count - 1; i >= 0; i--)
                {
                    var action = otherSkillActionList[i];
                    if (action.IsFinished())
                    {
                        otherSkillActionList.RemoveAt(i);
                        hasFinishedAction = true;
                    }
                }
                if (hasFinishedAction)
                {
                    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()
    {
        while (packList.Count > 0)
        {
            var pack = packList[0];
            packList.RemoveAt(0);

            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
                var otherSkillAction = combinePack.CreateSkillAction();
                otherSkillAction.fromSkillId = skillConfig.SkillID;
                otherSkillActionList.Add(otherSkillAction);
                return false;
            }
            else if (pack is HB428_tagSCBuffRefresh buffRefresh)
            {
                //   从找到第一个HB428开始 找出连续的HB428_tagSCBuffRefresh包 如果找到一个B428后 之后碰到非HB428包就停止
                buffCollections.Add(buffRefresh);
                while (packList.Count > 0)
                {
                    var nextPack = packList[0];
                    if (nextPack is HB428_tagSCBuffRefresh nextBuffRefresh)
                    {
                        buffCollections.Add(nextBuffRefresh);
                        packList.RemoveAt(0);
                    }
                    else
                    {
                        break;
                    }
                }

                // 同时刷新所有对象的buff，不分组
                foreach (var buff in buffCollections)
                {
                    BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buff.ObjID);
                    if (battleObj != null)
                    {
                        battleObj.buffMgr.RefreshBuff(buff, true);
                    }
                }

                // 清空已处理的buff集合
                buffCollections.Clear();
                continue;
            }

            if (pack is CustomB421ActionPack actionPack)
            {
                actionPack.Distribute();
            }
            else
            {
                PackageRegedit.Distribute(pack);
            }
        }

        return true;
    }

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