125 战斗 血条&护盾1护盾2表现

yyl

14 小时以前 2d3a60767d0cd69c8dec97e39937bcd0c667be1c

 Main/System/Battle/Skill/SkillBase.cs

@@ -489,25 +489,6 @@
    // 处理单个目标被命中:应用伤害和施法者效果
    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);
@@ -515,29 +496,21 @@
        long totalSuckHp = suckHp;
        List<long> suckHpList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, totalSuckHp);

        long totalReflectHp = hurt.BounceHP;
        List<long> reflectHpList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, totalReflectHp);

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


        // ============处理反伤 ===============
        //  也要按每一击平均算 最后要补齐伤害

        long reflectHp = hurt.BounceHP;


        List<long> reflectHpList = BattleUtility.DivideDamageToList(skillConfig.DamageDivide, _hitIndex, reflectHp);
        // 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)
@@ -545,54 +518,74 @@
            currentHitReflectHp += reflect;
        }

        long shieldValue = target.buffMgr.GetShieldValue();

        long remainSheild = shieldValue - currentHitDamage;

        long toShieldValue = Math.Max(0, shieldValue - currentHitDamage);

        long shieldRecieveDamage = shieldValue - toShieldValue;

        // if (shieldValue > 0 && remainSheild >= 0)
        // {
        //     currentHitDamage = 0;
        //     target.buffMgr.ReduceShieldValue(currentHitDamage);
        // }
        // else if (shieldValue > 0 && remainSheild < 0)
        // {
        //     currentHitDamage = Math.Abs(remainSheild);
        //     target.buffMgr.ClearShield();
        // }

        long toHp = fromHp; //Math.Max(0, fromHp - currentHitDamage);

        // ============ 第二步:获取目标当前状态 ============
        long fromHp = target.teamHero.curHp;
        long maxHp = target.teamHero.maxHp;
        long fromShieldValue = target.buffMgr.GetShieldValue();

        // 判断是治疗还是伤害
        bool isHealing = ((hurt.AttackTypes & (int)ServerDamageType.Recovery) != 0 || 
                          (hurt.AttackTypes & (int)ServerDamageType.DamageReverse) != 0) &&
                         (hurt.AttackTypes & (int)ServerDamageType.Damage) == 0 &&
                         (hurt.AttackTypes & (int)ServerDamageType.Realdamage) == 0 &&
                         (hurt.AttackTypes & (int)ServerDamageType.SuckHpReverse) == 0 &&
                         (hurt.AttackTypes & (int)ServerDamageType.SelfHarm) == 0;
        bool isHealing = BattleUtility.IsHealing(hurt);

        // ============ 第三步:计算目标血量和护盾变化 ============
        long toHp;
        long toShieldValue;

        if (isHealing)
        {
            // 治疗逻辑：直接加血，不考虑护盾
            toHp = Math.Min(target.teamHero.maxHp, fromHp + currentHitDamage);
            // 治疗逻辑：直接加血，护盾不变
            toHp = Math.Min(maxHp, fromHp + currentHitDamage);
            toShieldValue = fromShieldValue;
        }
        else
        {
            // 伤害逻辑：先扣护盾，再扣血
            if (remainSheild < 0)
            // 伤害逻辑：先扣护盾，护盾不足再扣血
            if (fromShieldValue >= currentHitDamage)
            {
                // 盾被打破
                toHp = Math.Max(0, fromHp + remainSheild);
                // 护盾足够承受所有伤害
                toShieldValue = fromShieldValue - currentHitDamage;
                toHp = fromHp;
            }
            else
            {
                // 护盾不足，先扣完护盾，剩余伤害扣血
                long remainingDamage = currentHitDamage - fromShieldValue;
                toShieldValue = 0;
                toHp = Math.Max(0, fromHp - remainingDamage);
            }
        }


        // 更新目标血量
        // ============ 第四步:更新目标实际血量 ============
        target.teamHero.curHp = toHp;

        // ============ 第五步:计算并更新施法者血量变化 ============
        long casterFromHp = caster.teamHero.curHp;
        long casterMaxHp = caster.teamHero.maxHp;
        long casterToHp = casterFromHp;

        // 处理吸血
        if (currentHitSuckHp > 0)
        {
            casterToHp = Math.Min(casterMaxHp, casterToHp + currentHitSuckHp);
        }

        // 处理反伤(施法者受到伤害)
        if (currentHitReflectHp > 0)
        {
            long casterShieldValue = caster.buffMgr.GetShieldValue();
            if (casterShieldValue >= currentHitReflectHp)
            {
                // 施法者护盾足够,血量不变
            }
            else
            {
                // 施法者护盾不足,扣血
                long remainingReflect = currentHitReflectHp - casterShieldValue;
                casterToHp = Math.Max(0, casterToHp - remainingReflect);
            }
        }

        // 更新施法者血量
        caster.teamHero.curHp = casterToHp;

#if UNITY_EDITOR
        BattleDebug.LogError(
@@ -600,37 +593,32 @@
            $"攻击者: {caster.teamHero.name}\n" +
            $"目标: {target.teamHero.name}\n" +
            $"技能: {skillConfig.SkillName} (第{_hitIndex}击)\n" +
            $"伤害: {currentHitDamage} 实际受到伤害: {fromHp-toHp} (总伤害: {totalDamage})\n" +
            $"承伤前护盾值: {shieldValue}\n" +
            $"承伤后护盾值: {toShieldValue}\n" +
            $"护盾承受伤害: {shieldRecieveDamage}\n" +
            $"伤害: {currentHitDamage} (总伤害: {totalDamage})\n" +
            $"吸血: {currentHitSuckHp}\n" +
            $"反伤: {currentHitReflectHp}\n" +
            $"血量变化: {fromHp} -> {toHp}\n" +
            $"技能包里的血量是: {GeneralDefine.GetFactValue(hurt.CurHP, hurt.CurHPEx)}\n"
            $"目标护盾变化: {fromShieldValue} -> {toShieldValue}\n" +
            $"目标血量变化: {fromHp} -> {toHp}\n" +
            $"施法者血量变化: {casterFromHp} -> {casterToHp}\n"
        );
#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);


        //  参数打包
        // ============ 第七步:参数打包并调用目标Hurt ============
        BattleHurtParam hurtParam = new BattleHurtParam()
        {
            casterObj = caster,
            hurtObj = target,
            damageList = damageList,
            suckHpList = suckHpList, //suckHpList,
            reflectHpList = reflectHpList,
            suckHpList = suckHpList,      // 用于casterDamageList飘字
            reflectHpList = reflectHpList, // 用于casterDamageList飘字
            fromHp = fromHp,
            toHp = toHp,
            maxHp = target.teamHero.maxHp,
            fromShieldValue = shieldValue,
            maxHp = maxHp,
            fromShieldValue = fromShieldValue,
            toShieldValue = toShieldValue,
            battleDrops = battleDrops,
            hurt = hurt,
@@ -639,10 +627,7 @@
            skillConfig = skillConfig
        };

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


    }

    // 处理HP刷新包（简化逻辑）