0312 去掉纠正战报中的新旧封包数据

hch

2026-01-07 d2280b3df8fddfad5b8a0ee04df7d4f2fd92f79b

 Main/System/Battle/Skill/SkillBase.cs

@@ -17,40 +17,146 @@
                                                        189f / 255f);

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

    protected List<BattleDeadPack> endDeadPackList = new List<BattleDeadPack>();

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

    private float MoveSpeed = 750f;

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

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


    // 构造函数：初始化技能基础数据
    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 (battleField != null && caster != null)
        {
            battleField.AddCastingSkill(caster.ObjID, this);
        }

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

#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.teamHero.name : "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.teamHero.name : "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()
    {
        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();
        }

        
    }

    // 技能运行主逻辑：处理技能效果和其他技能动作
@@ -134,6 +240,11 @@
        TeamHero teamHero = caster.teamHero;
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);

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

        if (caster != null)
        {
            // 战斗类型 0-常规；1-连击；2-反击；3-追击；4-子技能；5-被动触发的
@@ -151,11 +262,9 @@
                hintConfig = DamageNumConfig.Get(BattleConst.BattleChaseAttack);
            }
            
            if (hintConfig != null)
            {
                caster.heroInfoBar.ShowTips(((char)hintConfig.prefix).ToString(), true, false, 1.25f);
                // Debug.Break();
            }
            Hint(caster, hintConfig);


        }

        // 高亮所有本次技能相关的目标
@@ -187,6 +296,14 @@
        }
    }

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

    // 冲撞攻击模式（待实现）
    protected void DashCast(Action _onComplete)
    {
@@ -200,12 +317,19 @@
        RectTransform target = battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            // ShadowIllutionCreate(true);
            MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
            if (skillConfig.ClientTriggerTiming == 1)
            {
                // ShadowIllutionCreate(false);
                OnAttackFinish();
            }, MoveSpeed);
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);   
            }
        });
    }

@@ -219,7 +343,7 @@
            return;
        }

        int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);
        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);

@@ -241,12 +365,19 @@
        RectTransform target = battleField.GetTeamNode(caster.Camp, skillConfig);
        ExecuteMoveAndCastSequence(target, () =>
        {
            // ShadowIllutionCreate(true);
            MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
            if (skillConfig.ClientTriggerTiming == 1)
            {
                // ShadowIllutionCreate(false);
                OnAttackFinish();
            }, MoveSpeed);
            }
            else
            {
                // ShadowIllutionCreate(true);
                MoveToTarget(battleField.GetTeamNode(caster.Camp, caster.teamHero.positionNum), Vector2.zero, () =>
                {
                    // ShadowIllutionCreate(false);
                    OnAttackFinish();
                }, MoveSpeed);   
            }
        });
    }

@@ -256,9 +387,15 @@
        ShadowIllutionCreate(true);
        MoveToTarget(target, new Vector2(skillConfig.CastDistance, 0), () =>
        {
            if (skillConfig.CastDistance < 9999 && skillConfig.SkinllSFX2 != 0)
            {
                battleField.soundManager.PlayEffectSound(skillConfig.SkinllSFX2, false);
            }

            TurnBack(() =>
            {
                ShadowIllutionCreate(false);
                
                CastImpl(() =>
                {
                    TurnBack(() => 
@@ -338,16 +475,33 @@
    // 技能开始回调：处理死亡、子技能、技能效果初始化
    public void OnSkillStart()
    {
        if (isPlay)
        {
            Debug.LogError(" play twice OnSkillStart skillId :" + skillConfig.SkillID);
            return;
        }

        HandleDead();
        
        skillEffect = SkillEffectFactory.CreateSkillEffect(caster, skillConfig, tagUseSkillAttack);

        skillEffect = SkillEffectFactory.CreateSkillEffect(this, caster, skillConfig, tagUseSkillAttack);
        skillEffect.Play(OnHitTargets);
        foreach (var subSkillPack in tagUseSkillAttack.subSkillList)
        {
            SkillRecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic>() { subSkillPack });
            recordAction.fromSkill = this;
            otherSkillActionList.Add(recordAction);
            battleField.recordPlayer.ImmediatelyPlay(recordAction);
        }
        tagUseSkillAttack.subSkillList.Clear();
        foreach (var subCombinePack in tagUseSkillAttack.subSkillCombinePackList)
        {
            SkillRecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, subCombinePack.packList);
            recordAction.fromSkill = this;
            otherSkillActionList.Add(recordAction);
            battleField.recordPlayer.ImmediatelyPlay(recordAction);
        }
        tagUseSkillAttack.subSkillCombinePackList.Clear();

        isPlay = true;
    }

@@ -382,26 +536,63 @@
    // 高亮所有相关目标：设置施法者和目标的显示层级
    protected void HighLightAllTargets()
    {
        caster.layerMgr.SetSortingOrder(BattleConst.ActiveHeroActionSortingOrder);
        caster.layerMgr.SetSortingOrder(BattleConst.SkillMaskOrder + BattleConst.BattleActiveHeroOffset);

        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);
        // 收集所有目标（包含 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.heroInfoBar.SetActive(false);

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

            if (isHighlight)
            {
                bo.layerMgr.SetFront();
@@ -411,21 +602,27 @@
                bo.layerMgr.SetBack();
            }

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

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

    // 命中目标回调：处理所有被命中的目标

    // 命中目标回调：处理所有被命中的目标（包括主目标、弹射目标、溅射目标）
    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)?.teamHero.name))}");

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

        bool suckHp = true;

        // 处理主目标列表
        foreach (var hurt in hitList)
        {
        { 
            BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (target == null)
            {
@@ -433,120 +630,179 @@
                continue;
            }

            OnHitEachTarget(_hitIndex, target, hurt);
            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);
            }
        }

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

        
    }

    // 处理单个目标被命中:应用伤害和施法者效果
    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt)
    protected virtual void OnHitEachTarget(int _hitIndex, BattleObject target, HB427_tagSCUseSkill.tagSCUseSkillHurt hurt, bool suckHp)
    {
        // ============ 第一步:计算伤害分布 ============
        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);
        tempDeadPackList.TryGetValue(objID, out BattleDeadPack deadPack);


        //  参数打包
        BattleHurtParam hurtParam = new BattleHurtParam()
        // 如果目标正在释放技能，跳过死亡处理（延迟到技能结束）
        if (battleField != null && battleField.IsCastingSkill(target.ObjID))
        {
            casterObj = caster,
            hurtObj = target,
            damageList = damageList,
            suckHpList = suckHpList,
            reflectHpList = reflectHpList,
            fromHp = fromHp,
            toHp = toHp,
            battleDrops = battleDrops,
            hurt = hurt,
            hitIndex = _hitIndex,
            deadPack = deadPack,
            skillConfig = skillConfig
            deadPack = null;
        }

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

        // 先调用目标受伤
        target.Hurt(hurtParam);
        
        // 再调用施法者吸血/反伤
        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
        };

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


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

#if UNITY_EDITOR
    private void PrintHurtParamDebugInfo(BattleHurtParam hurtParam)
    {
        bool isLastHit = hurtParam.hitIndex >= hurtParam.skillConfig.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.teamHero.name} (ObjID:{hurtParam.caster.casterObj.ObjID})\n" +
            $"目标: {hurtParam.hurter.hurtObj.teamHero.name} (ObjID:{hurtParam.hurter.hurtObj.ObjID})\n" +
            $"技能: {hurtParam.skillConfig.SkillName} (ID:{hurtParam.skillConfig.SkillID})\n" +
            $"击数: 第{hurtParam.hitIndex + 1}击 / 共{hurtParam.skillConfig.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()
@@ -565,7 +821,7 @@
    // 处理死亡相关逻辑：分配掉落和经验
    protected void HandleDead()
    {
        var deadPackList = BattleUtility.FindDeadPack(packList);
        List<BattleDeadPack> deadPackList = BattleUtility.FindDeadPack(packList);
        if (deadPackList.Count <= 0) return;

        CheckAfterDeadhPack();
@@ -589,7 +845,8 @@
        // 构造BattleDrops并缓存
        for (int i = 0; i < deadPackList.Count; i++)
        {
            int objID = (int)deadPackList[i].ObjID;
            BattleDeadPack battleDeadPack = deadPackList[i];
            int objID = (int)battleDeadPack.deadPack.ObjID;
            BattleObject deadTarget = battleField.battleObjMgr.GetBattleObject(objID);
            
            // 修复：添加空值检查
@@ -631,7 +888,8 @@
        }

        // 修复：避免在遍历时修改集合，先收集后删除
        var deadPacksToRemove = new List<GameNetPackBasic>(deadPackList.Cast<GameNetPackBasic>());
        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);
@@ -725,11 +983,43 @@
            packList.RemoveAt(removeIndexList[i]);
    }


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

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

        if (otherSkillActionList.Count > 0)
        {
            foreach (var action in otherSkillActionList)
            {
                if (!action.IsFinishedForJudge()) return false;
            }
        }

        if (isFinished && moveFinished)
        {
            if (packList.Count > 0)
            {
                return false;
            }

            return true;
        }

        return false;
    }

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

        // 检查技能效果是否完成
        if (skillEffect != null)
@@ -737,7 +1027,7 @@
            if (!skillEffect.IsFinished()) return false;
            skillEffect = null;
            OnSkillFinished();
            return false;
            tempRetValue = false;
        }

        // 检查其他技能动作是否完成
@@ -752,7 +1042,15 @@
                    OnSkillFinished();
                }
            }
            if (otherSkillActionList.Count > 0) return false;
            if (otherSkillActionList.Count > 0)
            {
                tempRetValue = false;
            }
        }

        if (!tempRetValue)
        {
            return false;
        }

        // 检查最终完成状态
@@ -762,6 +1060,14 @@
            {
                OnSkillFinished();
                return false;
            }

            // 技能完全结束，移除技能注册并触发延迟的死亡判定
            if (battleField != null && caster != null)
            {
                battleField.RemoveCastingSkill(caster.ObjID, this);
                
                battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values));
            }

            return true;
@@ -774,16 +1080,106 @@
    // 强制结束技能：立即结束所有技能相关的处理
    public virtual void ForceFinished()
    {
        if (isFinished)
            return;

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

        battleField.OnObjsDead(new List<BattleDeadPack>(tempDeadPackList.Values));

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

        foreach (var subSkillPack in tagUseSkillAttack.subSkillList)
        {
            SkillRecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, new List<GameNetPackBasic>() { subSkillPack });
            recordAction.fromSkill = this;
            otherSkillActionList.Add(recordAction);
            battleField.recordPlayer.ImmediatelyPlay(recordAction);
        }
        tagUseSkillAttack.subSkillList.Clear();
        foreach (var subCombinePack in tagUseSkillAttack.subSkillCombinePackList)
        {
            SkillRecordAction recordAction = CustomHB426CombinePack.CreateSkillAction(battleField.guid, subCombinePack.packList);
            recordAction.fromSkill = this;
            otherSkillActionList.Add(recordAction);
            battleField.recordPlayer.ImmediatelyPlay(recordAction);
        }
        tagUseSkillAttack.subSkillCombinePackList.Clear();
        
        // 2. 强制结束所有子技能动作
        otherSkillActionList.ForEach(action => action.ForceFinish());
        otherSkillActionList.Clear();

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

        // 4. 重置施法者状态
        if (caster != null)
        {
            // 重置位置到原点
            if (caster.heroRectTrans != null)
            {
                caster.heroRectTrans.anchoredPosition = Vector2.zero;
            }
            
            // 重置朝向
            if (caster.heroGo != null)
            {
                Vector3 scale = caster.heroGo.transform.localScale;
                scale.x = Mathf.Abs(scale.x);
                caster.heroGo.transform.localScale = scale;
            }

            // 取消幻影效果
            caster.motionBase?.ShowIllusionShadow(false);
            
            // 播放待机动画（如果还活着）
            if (!caster.teamHero.isDead)
            {
                caster.motionBase?.ResetForReborn(false);
            }
        }

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

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

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

        // 处理剩余的 packList
        while (packList.Count > 0)
        {
            var pack = packList[0];
@@ -792,7 +1188,7 @@
            if (pack is CustomHB426CombinePack combinePack && combinePack.startTag.Tag.StartsWith("Skill_"))
            {
                var otherSkillAction = combinePack.CreateSkillAction();
                otherSkillAction.fromSkillId = skillConfig.SkillID;
                otherSkillAction.fromSkill = this;
                otherSkillAction.ForceFinish();
            }
            else
@@ -873,20 +1269,20 @@
            {
                BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
                var otherSkillAction = combinePack.CreateSkillAction();
                otherSkillAction.fromSkillId = skillConfig.SkillID;
                otherSkillAction.fromSkill = this;
                otherSkillActionList.Add(otherSkillAction);
                return false;
            }
            else if (pack is HB428_tagSCBuffRefresh buffRefresh)
            else if (IsBuffPack(pack))
            {
                //   从找到第一个HB428开始 找出连续的HB428_tagSCBuffRefresh包 如果找到一个B428后 之后碰到非HB428包就停止
                buffCollections.Add(buffRefresh);
                // 从找到第一个 Buff 包开始，收集连续的 HB428/HB429 包
                buffPackCollections.Add(pack);
                while (packList.Count > 0)
                {
                    var nextPack = packList[0];
                    if (nextPack is HB428_tagSCBuffRefresh nextBuffRefresh)
                    if (IsBuffPack(nextPack))
                    {
                        buffCollections.Add(nextBuffRefresh);
                        buffPackCollections.Add(nextPack);
                        packList.RemoveAt(0);
                    }
                    else
@@ -895,18 +1291,11 @@
                    }
                }

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

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

@@ -931,8 +1320,63 @@
        otherSkillActionList?.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)
                {
                    battleObj.buffMgr.RefreshBuff(buffRefresh, true);
                }
            }
            else if (pack is HB429_tagSCBuffDel buffDel)
            {
                BattleObject battleObj = battleField.battleObjMgr.GetBattleObject((int)buffDel.ObjID);
                if (battleObj != null)
                {
                    battleObj.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)
        {
            PackageRegedit.Distribute(pack);
        }
    }

    #endregion

}