125 【战斗】战斗系统 战斗封包处理 支持B426拆分FightAction 支持多重嵌套

yyl

昨天 8d42bc7ab52a3980df2778d2ee7757e60914e6e0

125 【战斗】战斗系统 战斗封包处理 支持B426拆分FightAction 支持多重嵌套

 Main/Core/NetworkPackage/CustomServerPack/CustomHB426CombinePack.cs

@@ -81,6 +81,7 @@
        for (int i = 0; i < b421SeriesPackList.Count; i++)
        {
            var pack = b421SeriesPackList[i];

            if (pack is HB426_tagSCTurnFightTag)
            {
                var tag = pack as HB426_tagSCTurnFightTag;
@@ -156,6 +157,8 @@
            }
        }

        // newPackList = BattleManager.ParseBattlePackList(_guid, newPackList);

        // Debug.LogError(temp);

        return newPackList;

 Main/Core/NetworkPackage/DTCFile/ServerPack/HB4_FightDefine/DTCB427_tagSCUseSkill.cs

@@ -14,6 +14,18 @@
        // 正常来说 都是要包b426的 但是有些技能不需要 例如挂BUFF的 所以暂时支持这么做 如果后续有更复杂的BUFF再改 25 9/22 YYL
        if (null != battleField)
        {
            BattleObject caster = battleField.battleObjMgr.GetBattleObject((int)vNetData.ObjID);

            //不走CombinePack的技能导致不在流程内 所以执行起来的时候已经清空数据了
            if (null == caster)
            {
                // foreach (var bo in battleField.battleObjMgr.allBattleObjDict.Values)
                // {
                //     Debug.LogError("当前有的 DTCB427_tagSCUseSkill: battleObjMgr has obj id: " + bo.ObjID);
                // }
                return;
            }

            SkillRecordAction skillRecord = new SkillRecordAction(battleField, battleField.battleObjMgr.GetBattleObject((int)vNetData.ObjID), vNetData, new System.Collections.Generic.List<GameNetPackBasic>());
            battleField.PlayRecord(skillRecord);
        }

 Main/Core/NetworkPackage/DTCFile/ServerPack/HB4_FightDefine/DTCB430_tagSCTurnFightReport.cs

@@ -99,56 +99,57 @@
        // 为防止死循环，可强制回城休息，让玩家重新点击关卡战斗或挑战boss，
        // 正常情况下在战锤足够时理论上都可以一直循环刷怪，如果连续多次没有战斗片段封包，比如限制个连续10次以内，就可以理解为异常了

        const int MaxContinousEmptyCount = 10; // 连续空包最大次数
        // const int MaxContinousEmptyCount = 10; // 连续空包最大次数

        List<GameNetPackBasic> packQueueSnapshot = new List<GameNetPackBasic>(vPackList);

        List<GameNetPackBasic> newPackList = new List<GameNetPackBasic>();
        HashSet<int> skipIndexes = new HashSet<int>();
        List<GameNetPackBasic> newPackList = BattleManager.ParseBattlePackList(guid, packQueueSnapshot);
        // List<GameNetPackBasic> newPackList = new List<GameNetPackBasic>();
        // HashSet<int> skipIndexes = new HashSet<int>();

        // 这里已经是按照Dequeue的顺序了
        for (int i = 0; i < packQueueSnapshot.Count; i++)
        {
            if (skipIndexes.Contains(i)) continue;
        // // 这里已经是按照Dequeue的顺序了
        // for (int i = 0; i < packQueueSnapshot.Count; i++)
        // {
        //     if (skipIndexes.Contains(i)) continue;

            GameNetPackBasic pack = packQueueSnapshot[i];
        //     GameNetPackBasic pack = packQueueSnapshot[i];

            // 碰到B421 截断 往下收集b421里的全部内容
            if (pack is HB421_tagMCTurnFightObjAction)
            {
                HB421_tagMCTurnFightObjAction b421Pack = pack as HB421_tagMCTurnFightObjAction;
        //     // 碰到B421 截断 往下收集b421里的全部内容
        //     if (pack is HB421_tagMCTurnFightObjAction)
        //     {
        //         HB421_tagMCTurnFightObjAction b421Pack = pack as HB421_tagMCTurnFightObjAction;

                List<GameNetPackBasic> b421PackList = new List<GameNetPackBasic>();
                i++;    // 跳过当前的B421包
        //         List<GameNetPackBasic> b421PackList = new List<GameNetPackBasic>();
        //         i++;    // 跳过当前的B421包

                // 收集所有非B421包，直到遇到下一个B421或队列结束
                for (; i < packQueueSnapshot.Count; i++)
                {
                    GameNetPackBasic nextPack = packQueueSnapshot[i];
                    if (nextPack is HB421_tagMCTurnFightObjAction)
                    {
                        i--; // 回退一个位置，留给外层循环处理
                        break;
                    }
                    else
                    {
                        b421PackList.Add(nextPack);
                        skipIndexes.Add(i); // 标记已被合包
                    }
                }
        //         // 收集所有非B421包，直到遇到下一个B421或队列结束
        //         for (; i < packQueueSnapshot.Count; i++)
        //         {
        //             GameNetPackBasic nextPack = packQueueSnapshot[i];
        //             if (nextPack is HB421_tagMCTurnFightObjAction)
        //             {
        //                 i--; // 回退一个位置，留给外层循环处理
        //                 break;
        //             }
        //             else
        //             {
        //                 b421PackList.Add(nextPack);
        //                 skipIndexes.Add(i); // 标记已被合包
        //             }
        //         }



                // 合并所有相关包
                CustomB421ActionPack actionPack = CustomB421ActionPack.CreateB421ActionPack(guid, b421PackList);
        //         // 合并所有相关包
        //         CustomB421ActionPack actionPack = CustomB421ActionPack.CreateB421ActionPack(guid, b421PackList);

                newPackList.Add(actionPack);
            }
            else
            {
                newPackList.Add(pack);
            }
        }
        //         newPackList.Add(actionPack);
        //     }
        //     else
        //     {
        //         newPackList.Add(pack);
        //     }
        // }


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

 Main/Core/NetworkPackage/GameNetPackBasic.cs

@@ -10,10 +10,18 @@

    static ulong AutoIncreaseUID = 0;

    public ulong mPackUID;

    public ulong packUID
    {
        get;
        private set;
        get
        {
            return mPackUID;
        }
        private set
        {
            mPackUID = value;
        }
    }

    public GameNetPackBasic()

 Main/System/Battle/BattleField/BattleField.cs

@@ -274,9 +274,11 @@
        //  Msg;    //size = Len   +



        if (State == 4)
        {
            //已经结束并结算
            Debug.Log("战斗结束");
            OnBattleEnd(turnFightStateData);
            return;
        }

 Main/System/Battle/BattleField/RecordActions/BattleEndAction.cs

@@ -22,7 +22,6 @@
    {
        base.Run();

        Debug.Log("Battle Ended");
        isFinish = true;
        onComplete?.Invoke();
    }

 Main/System/Battle/BattleField/RecordActions/DeathRecordAction.cs

@@ -1,5 +1,6 @@
using UnityEngine;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;

public class DeathRecordAction : RecordAction
{
@@ -30,16 +31,21 @@
            int total = deadPackList.Count;
            foreach (var deadPack in deadPackList)
            {
                index++;
                isLastOne = index >= total;
                BattleObject deadObj = battleField.battleObjMgr.GetBattleObject((int)deadPack.ObjID);
                deadObj.OnDeath(() =>
                {
                    index++;

                    isLastOne = index >= total;

                    OnDeathAnimationEnd(deadObj);

                    if (isLastOne)
                    {
                        isFinish = true;
                        UniTaskExtension.DelayTime((GameObject)null, 0.3f / battleField.speedRatio, () =>
                        {
                            isFinish = true;
                        });
                    }
                });
            }

 Main/System/Battle/BattleField/RecordActions/SkillRecordAction.cs

@@ -57,7 +57,8 @@
        {
            BattleDebug.LogError("cast skill from skill : " + fromSkillId);
        }
			

        // Debug.LogError("cast skill id is " + skillBase.skillConfig.SkillID);

        skillBase.fromSkillId = fromSkillId;


 Main/System/Battle/BattleManager.cs

@@ -125,52 +125,52 @@

        List<GameNetPackBasic> packQueueSnapshot = new List<GameNetPackBasic>(packQueue);

        List<GameNetPackBasic> newPackList = new List<GameNetPackBasic>();
        HashSet<int> skipIndexes = new HashSet<int>();
        List<GameNetPackBasic> newPackList = ParseBattlePackList(string.Empty, packQueueSnapshot);
        // HashSet<int> skipIndexes = new HashSet<int>();

        // 这里已经是按照Dequeue的顺序了
        for (int i = 0; i < packQueueSnapshot.Count; i++)
        {
            if (skipIndexes.Contains(i)) continue;
        // // 这里已经是按照Dequeue的顺序了
        // for (int i = 0; i < packQueueSnapshot.Count; i++)
        // {
        //     if (skipIndexes.Contains(i)) continue;

            GameNetPackBasic pack = packQueueSnapshot[i];
        //     GameNetPackBasic pack = packQueueSnapshot[i];

            // 碰到B421 截断 往下收集b421里的全部内容
            if (pack is HB421_tagMCTurnFightObjAction)
            {
                HB421_tagMCTurnFightObjAction b421Pack = pack as HB421_tagMCTurnFightObjAction;
        //     // 碰到B421 截断 往下收集b421里的全部内容
        //     if (pack is HB421_tagMCTurnFightObjAction)
        //     {
        //         HB421_tagMCTurnFightObjAction b421Pack = pack as HB421_tagMCTurnFightObjAction;

                List<GameNetPackBasic> b421PackList = new List<GameNetPackBasic>();
                i++;    // 跳过当前的B421包
        //         List<GameNetPackBasic> b421PackList = new List<GameNetPackBasic>();
        //         i++;    // 跳过当前的B421包

                // 收集所有非B421包，直到遇到下一个B421或队列结束
                for (; i < packQueueSnapshot.Count; i++)
                {
                    GameNetPackBasic nextPack = packQueueSnapshot[i];
                    if (nextPack is HB421_tagMCTurnFightObjAction)
                    {
                        i--; // 回退一个位置，留给外层循环处理
                        break;
                    }
                    else
                    {
                        b421PackList.Add(nextPack);
                        skipIndexes.Add(i); // 标记已被合包
                    }
                }
        //         // 收集所有非B421包，直到遇到下一个B421或队列结束
        //         for (; i < packQueueSnapshot.Count; i++)
        //         {
        //             GameNetPackBasic nextPack = packQueueSnapshot[i];
        //             if (nextPack is HB421_tagMCTurnFightObjAction)
        //             {
        //                 i--; // 回退一个位置，留给外层循环处理
        //                 break;
        //             }
        //             else
        //             {
        //                 b421PackList.Add(nextPack);
        //                 skipIndexes.Add(i); // 标记已被合包
        //             }
        //         }



                // 合并所有相关包
                CustomB421ActionPack actionPack = CustomB421ActionPack.CreateB421ActionPack(GetGUID(b421Pack.packUID), b421PackList);
        //         // 合并所有相关包
        //         CustomB421ActionPack actionPack = CustomB421ActionPack.CreateB421ActionPack(GetGUID(b421Pack.packUID), b421PackList);

                newPackList.Add(actionPack);
            }
            else
            {
                newPackList.Add(pack);
            }
        }
        //         newPackList.Add(actionPack);
        //     }
        //     else
        //     {
        //         newPackList.Add(pack);
        //     }
        // }

        // 防范机制：连续多次没有战斗片段封包时自动回城
        if (newPackList.Count == 0)
@@ -208,6 +208,131 @@
        DistributeNextPackage();
    }

    public static List<GameNetPackBasic> ParseBattlePackList(string guid, List<GameNetPackBasic> packQueueSnapshot)
    {
        bool wrong = false;

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

        HB421_tagMCTurnFightObjAction b421Pack = null;

        for (int i = 0; i < packQueueSnapshot.Count; i++)
        {
            GameNetPackBasic pack = packQueueSnapshot[i];
            if (null == b421Pack)
            {
                if (pack is HB421_tagMCTurnFightObjAction _b421)
                {
                    b421Pack = _b421;
                }
                else
                {
                    newPackList.Add(pack);
                }
                continue;
            }
            else
            {
                List<GameNetPackBasic> b421List = new List<GameNetPackBasic>();

                bool find = false;

                for (int k = i; k < packQueueSnapshot.Count; k++/*, Debug.LogError(k + " : is plusing")*/)
                {
                    GameNetPackBasic maybeB426Pack = packQueueSnapshot[k];

                    if (maybeB426Pack is HB426_tagSCTurnFightTag b426Pack)
                    {
                        // Debug.LogError(k + " : find b426 " + maybeB426Pack.packUID + " sign " + b426Pack.Sign + " tag " + b426Pack.Tag);
                        if (b426Pack.Sign == 0)
                        {
                            find = true;
                            List<GameNetPackBasic> b426List = new List<GameNetPackBasic>();
                            b426List.Add(b426Pack);
                            for (int j = k + 1; j < packQueueSnapshot.Count; j++)
                            {
                                GameNetPackBasic maybeB426EndPack = packQueueSnapshot[j];
                                if (maybeB426EndPack is HB426_tagSCTurnFightTag b426EndPack)
                                {
                                    // Debug.LogError(j + " : find b426 end pack : " + b426EndPack.packUID + " sign " + b426EndPack.Sign + " tag " + b426EndPack.Tag);

                                    if (b426EndPack.Tag == b426Pack.Tag)
                                    {
                                        if (b426EndPack.Sign == 1)
                                        {
                                            b426List.Add(maybeB426EndPack);
                                            k = j;
                                            i = k;
                                            break;
                                        }
                                        else
                                        {
                                            Debug.LogError("错误的Sign == 1");
                                            continue;
                                        }
                                    }
                                    else
                                    {
                                        //  新的一对
                                    }
                                }
                                else
                                {
                                    b426List.Add(maybeB426EndPack);
                                    k = j;
                                    i = k;
                                }
                            }
                            //    这里面的b421还没处理
                            List<GameNetPackBasic> combinedList = CustomHB426CombinePack.CombineToSkillPackFromList(guid, b426List);
                            b421List.AddRange(combinedList);
                        }
                        else
                        {
                            wrong = true;
                            Debug.LogError("错误的b426 分析有问题 " + b426Pack.packUID);
                        }
                    }
                    else
                    {
                        if (!find)
                        {
                            newPackList.Add(maybeB426Pack);
                            i = k;
                        }
                        else
                        {
                            if (maybeB426Pack is HB421_tagMCTurnFightObjAction _b421)
                            {
                                i = k - 1;
                                break;
                            }

                            b421List.Add(maybeB426Pack);
                            i = k;
                        }
                    }
                }
                CustomB421ActionPack actionPack = CustomB421ActionPack.CreateB421ActionPack(guid, b421List);
                newPackList.Add(actionPack);
                b421Pack = null;
            }
        }

        if (wrong)
        {
            string output = string.Empty;
            for (int f = 0; f < packQueueSnapshot.Count; f++)
            {
                output += (packQueueSnapshot[f].packUID  + "&" + packQueueSnapshot[f].GetType().ToString() + "|");
            }

            Debug.LogError(output);
        }

        return newPackList;
    }

    //  专属于主线战斗的派发
    public bool DistributeNextPackage()
    {

 Main/System/Battle/Skill/SkillBase.cs

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


public class SkillBase
@@ -14,7 +14,7 @@

    protected HB427_tagSCUseSkill tagUseSkillAttack;

    protected SkillConfig skillConfig;
    public SkillConfig skillConfig;

    protected bool isFinished = false;

@@ -39,6 +39,10 @@
    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;
@@ -82,7 +86,9 @@
    // 1·移动到距离阵容位置n码的距离（如2号位，5号位）释放（即战场中央此类）
    public virtual void Cast()
    {
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, battleField.guid, skillConfig, caster.teamHero);
        string guid = battleField.guid;
        TeamHero teamHero = caster.teamHero;
        EventBroadcast.Instance.Broadcast<string, SkillConfig, TeamHero>(EventName.BATTLE_CAST_SKILL, guid, skillConfig, teamHero);

        //    高亮所有本次技能相关的目标
        HighLightAllTargets();
@@ -645,9 +651,8 @@
            var pack = packList[0];
            packList.RemoveAt(0);

            if (pack is CustomHB426CombinePack)
            if (pack is CustomHB426CombinePack combinePack)
            {
                var combinePack = pack as CustomHB426CombinePack;
                if (combinePack.startTag.Tag.StartsWith("Skill_"))
                {
                    BattleDebug.LogError("other skill casting " + combinePack.startTag.Tag);
@@ -657,6 +662,11 @@
                    otherSkillAction.ForceFinish();
                    return;
                }
            }
            else if (pack is CustomB421ActionPack actionPack)
            {
                actionPack.Distribute();
                return;
            }
            PackageRegedit.Distribute(pack);
        }
@@ -688,6 +698,11 @@
                    return;
                }
            }
            else if (pack is CustomB421ActionPack actionPack)
            {
                actionPack.Distribute();
                return;
            }
            PackageRegedit.Distribute(pack);
        }