NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/PVP/PVPDefenderData.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Cysharp.Threading.Tasks;
using Framework.Wrapper;
using Gameplay.Level;
using Gameplay.Net;
using Google.Protobuf;
using NLDPB;
using UnityEngine;
using CharacterInfo = Gameplay.Net.CharacterInfo;

/// <summary>
/// pvp防守方上阵数据
/// </summary>
public class PVPDefenderData
{
    public List<PVPUnitRuntimeInfo> pvpRuntimeUnitInfos = new();

    public List<PVPUnitInfo> PVPUnitInfos =>
        pvpRuntimeUnitInfos.Select(runtimeInfo => runtimeInfo.pvpUnitInfo).ToList();

    public PVPDefenderData()
    {
    }

    public PVPDefenderData(MSG_PvpDefenceData pvpDefenceData)
    {
        //DebugUtil.LogError($"pvpDefenceData:{pvpDefenceData.ToString()}");
        var unitCellInfos = MSG_PvpTeamData.Parser.ParseFrom(pvpDefenceData.TeamData);
        List<CharacterInfo> characterInfos = new();
        if (pvpDefenceData.Characters != null)
        {
            foreach (var serverCharacterInfo in pvpDefenceData.Characters)
            {
                CharacterInfo characterInfo = new()
                {
                    ID = serverCharacterInfo.Id,
                };
                characterInfo.Refresh(serverCharacterInfo);
                characterInfos.Add(characterInfo);
            }
            //DebugUtil.Log($"PVPEnemyInfo: characters count{characterInfos.Count}");
        }
        
        List<Gameplay.Net.VehicleInfo> vehicleInfos = new();
        if (pvpDefenceData.Vehicle != null)
        {
            foreach (var serverVehicleInfo in pvpDefenceData.Vehicle)
            {
                Gameplay.Net.VehicleInfo vehicleInfo = new()
                {
                    nID = serverVehicleInfo.Id,
                };
                vehicleInfo.Refresh(serverVehicleInfo);
                vehicleInfos.Add(vehicleInfo);
            }
            //DebugUtil.Log($"PVPEnemyInfo: vehicleInfos count{vehicleInfos.Count}");
        }

        List<FightBuildingData> buildingInfos = new();
        if (pvpDefenceData.BuildingId != null)
        {
            for (int i = 0; i < pvpDefenceData.BuildingId.Count; i++)
            {
                var id = pvpDefenceData.BuildingId[i];
                var buildingData = FightBuildingDataManager.Instance.DataDic[id];
                //刷新数据
                buildingInfos.Add(buildingData);
            }
            //DebugUtil.Log($"PVPEnemyInfo: vehicleInfos count{vehicleInfos.Count}");
        }

        var unitInfos = new List<PVPUnitInfo>() { };
        for (int i = 0; i< characterInfos.Count; i++ )
        {
            var characterInfo = characterInfos[i];
            var unit = new PVPUnitInfo()
            {
                unitID = characterInfo.ID,
                type = Unit.UnitType.Charactor,
                cellIndex = (int)unitCellInfos.CharacterCell[i] - 1
            };
            unitInfos.Add(unit);
        }

        for (int i = 0; i < vehicleInfos.Count; i++)
        {
            var vehicleInfo = vehicleInfos[i];
            var unit = new PVPUnitInfo()
            {
                unitID = vehicleInfo.nID,
                type = Unit.UnitType.Vehicle,
                cellIndex = (int)unitCellInfos.VehicleCell[i] - 1
            };
            unitInfos.Add(unit);
        }

        if (unitCellInfos.BuildingCell != null)
        {
            for (int i = 0; i < buildingInfos.Count; i++)
            {
                var buildingData = buildingInfos[i];
                var unit = new PVPUnitInfo()
                {
                    unitID = buildingData.Uid,
                    type = Unit.UnitType.Building,
                    cellIndex = (int)unitCellInfos.BuildingCell[i] - 1
                };
                unitInfos.Add(unit);
            }
        }

        //DebugUtil.Log($"PVPEnemyInfo: unitInfos count{unitInfos.Count}");
        Init(unitInfos, characterInfos, vehicleInfos, buildingInfos);
    }

    public void Init(List<PVPUnitInfo> unitInfos, List<CharacterInfo> characterInfos,
        List<Gameplay.Net.VehicleInfo> vehicleInfos, List<FightBuildingData> buildingInfos)
    {
        pvpRuntimeUnitInfos.Clear();
        int characterIndex = 0;
        int vehicleIndex = 0;
        int bulidIndex = 0;
        for (int i = 0; i < unitInfos.Count; i++)
        {
            var unitInfo = unitInfos[i];
            CharacterInfo characterInfo = null;
            Gameplay.Net.VehicleInfo currVehicleInfo = null;
            FightBuildingData buildingData = null;
            switch (unitInfo.type)
            {
                case Unit.UnitType.Charactor:
                    characterInfo = characterInfos[characterIndex];
                    // if (!CharacterDataInfoManager.Instance.DataDic.ContainsKey(characterInfo.ID))
                    // {
                    //     continue;
                    // }
                    characterIndex++;
                    break;
                case Unit.UnitType.Vehicle:
                    currVehicleInfo = vehicleInfos[vehicleIndex];
                    // if (!VehicleCultivateDataManager.Instance.DataDic.ContainsKey(currVehicleInfo.nID))
                    // {
                    //     continue;
                    // }
                    vehicleIndex++;
                    break;
                case Unit.UnitType.Building:
                    buildingData = buildingInfos[bulidIndex];
                    // if (!FightBuildingDataManager.Instance.DataDic.ContainsKey(buildingData.Uid))
                    // {
                    //     continue;
                    // }
                    bulidIndex++;
                    break;
                default:
                    break;
            }

            PVPUnitRuntimeInfo runtimeInfo = new(unitInfo, characterInfo, currVehicleInfo, buildingData);
            pvpRuntimeUnitInfos.Add(runtimeInfo);
        }
        
        //DebugUtil.Log($"PVPEnemyInfo: pvpRuntimeUnitInfos count:{pvpRuntimeUnitInfos.Count}");
    }
}

/// <summary>
/// 单个战斗单元上阵数据，该数据会序列化后发送给服务器
/// </summary>
[Serializable]
public class PVPUnitInfo
{
    [Serializable]
    private class PVPUnitInfoListData
    {
        public List<PVPUnitInfo> unitInfos;
    }

    public uint unitID;

    public Unit.UnitType type = Unit.UnitType.Charactor;

    public int cellIndex;

    public LevelData.AIType aiType = LevelData.AIType.BasicAI;

    public LevelData.AttachAIType attachAIType = LevelData.AttachAIType.ChainAI;

    public static byte[] Serialize(List<PVPUnitInfo> unitInfos)
    {
        // var listData = new PVPUnitInfoListData()
        // {
        //     unitInfos = unitInfos,
        // };
        //var jsonStr = JsonUtility.ToJson(listData);
        MSG_PvpTeamData teamData = new MSG_PvpTeamData() { };
        foreach (var unit in unitInfos)
        {
            if (unit.type == Unit.UnitType.Charactor)
            {
                teamData.CharacterCell.Add((uint)unit.cellIndex + 1);
            }
            else if (unit.type == Unit.UnitType.Building)
            {
                teamData.BuildingCell.Add((uint)unit.cellIndex + 1);
            }
            else
            {
                teamData.VehicleCell.Add((uint)unit.cellIndex + 1);
            }
        }
        
        return teamData.ToByteArray();
    }

    public static MSG_PvpTeamData DeSerialize(byte[] bytes)
    {
        if (bytes == null)
            return null;
        //var jsonStr = System.Text.Encoding.UTF8.GetString(bytes);
        MSG_PvpTeamData teamData = MSG_PvpTeamData.Parser.ParseFrom(bytes);
        return teamData;
    }

    public static List<PVPUnitInfo> ParsePvpDefenceData(MSG_PvpDefenceData pvpDefenceData)
    {
        var characterIDs = new List<uint>(pvpDefenceData.Characters.Select(character => character.Id));
        var vehicleIDs = new List<uint>(pvpDefenceData.Vehicle.Select(v => v.Id));
        var buildingIDs = pvpDefenceData.BuildingId;
        var teamData = MSG_PvpTeamData.Parser.ParseFrom(pvpDefenceData.TeamData);

        var pvpUnitInfos = new List<PVPUnitInfo>();
        for (int i = 0; i < characterIDs.Count; i++)
        {
            var unit = new PVPUnitInfo()
            {
                unitID = characterIDs[i],
                cellIndex = (int)teamData.CharacterCell[i] - 1,
                type = Unit.UnitType.Charactor
            };
            pvpUnitInfos.Add(unit);
        }

        for (int i = 0; i < vehicleIDs.Count; i++)
        {
            var unit = new PVPUnitInfo()
            {
                unitID = vehicleIDs[i],
                cellIndex = (int)teamData.VehicleCell[i] - 1,
                type = Unit.UnitType.Vehicle
            };
            pvpUnitInfos.Add(unit);
        }
        
        for (int i = 0; i < buildingIDs.Count; i++)
        {
            var unit = new PVPUnitInfo()
            {
                unitID = buildingIDs[i],
                cellIndex = (int)teamData.BuildingCell[i] - 1,
                type = Unit.UnitType.Building
            };
            pvpUnitInfos.Add(unit);
        }

        return pvpUnitInfos;
    }

    public static List<PVPUnitInfo> ParseMyPvpDefenceData()
    {
        var characterIDs = Actor.Instance.Pvp.CharacterIDs;
        var vehicleIDs = Actor.Instance.Pvp.VehicleIDs;
        var buildingIDs = Actor.Instance.Pvp.BuildingIds;
        var teamDataBytes = Actor.Instance.Pvp.TeamData;
        var teamData = MSG_PvpTeamData.Parser.ParseFrom(teamDataBytes);

        var pvpUnitInfos = new List<PVPUnitInfo>();
        for (int i = 0; i < characterIDs.Count; i++)
        {
            var unit = new PVPUnitInfo()
            {
                unitID = characterIDs[i],
                cellIndex = (int)teamData.CharacterCell[i] - 1,
                type = Unit.UnitType.Charactor
            };
            pvpUnitInfos.Add(unit);
        }

        for (int i = 0; i < vehicleIDs.Count; i++)
        {
            var vehicleID = vehicleIDs[i];
            if (vehicleID > 0 && VehicleCultivateDataManager.Instance.DataDic.ContainsKey(vehicleID))
            {
                var unit = new PVPUnitInfo()
                {
                    unitID = vehicleID,
                    cellIndex = (int)teamData.VehicleCell[i] - 1,
                    type = Unit.UnitType.Vehicle
                };
                pvpUnitInfos.Add(unit);
            }
        }

        
        for (int i = 0; i < buildingIDs.Count; i++)
        {
            var id = buildingIDs[i];
            var unit = new PVPUnitInfo()
            {
                unitID = id,
                cellIndex = (int)teamData.BuildingCell[i] - 1,
                type = Unit.UnitType.Building
            };
            pvpUnitInfos.Add(unit);
        }
            
            
        return pvpUnitInfos;
    }
}

public class PVPUnitRuntimeInfo
{
    public PVPUnitInfo pvpUnitInfo { get; private set; }

    public uint unitID => pvpUnitInfo.unitID;

    public Unit.UnitType type => pvpUnitInfo.type;

    public int cellIndex => pvpUnitInfo.cellIndex;

    public LevelData.AIType aiType => pvpUnitInfo.aiType;

    public LevelData.AttachAIType attachAIType => pvpUnitInfo.attachAIType;

    public Gameplay.Net.CharacterInfo characterInfo { get; private set; }
    public Gameplay.Net.VehicleInfo vehicleInfo { get; private set; }


    public FightBuildingData fightBuildingData{ get; private set; }
    public PVPUnitRuntimeInfo(PVPUnitInfo pvpUnitInfo, Gameplay.Net.CharacterInfo characterInfo,
        Gameplay.Net.VehicleInfo vehicleInfo, FightBuildingData buildingData)
    {
        this.pvpUnitInfo = pvpUnitInfo;
        this.characterInfo = characterInfo;
        this.vehicleInfo = vehicleInfo;
        this.fightBuildingData = buildingData;
    }
}