NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/Team/TeamManager.cs

using System;
using System.Collections.Generic;
using System.Linq;
using cfg.CharacterCfg;
using cfg.VehicleCfg;
using Cysharp.Threading.Tasks;
using UnityEngine;
using Framework;
using Gameplay;
using Gameplay.Area;
using Gameplay.Area.Ready;
using Gameplay.Character;
using Gameplay.Level;
using Gameplay.Unit;
using Gameplay.Unit.Data;
using PhxhSDK;
using Constants = Framework.Constants;
using EventManager = Framework.EventManager;

//队伍管理器
public partial class TeamManager
{
    private static TeamManager m_instance;
    private TeamManager()
    {
        
    }

    public int TotalLimit
    {
        get
        {
            return 7;
        }
    }
    private const int FIGHT_LIMIT = 5;
    private const int VEHICLE_FIGHT_LIMIT = 3;
    private const int WAIT_LIMIT = 7;
    public const int TOTAL_LIMIT = 6;

    //指挥官技能
    private CommandSkillManager _commonSkillMgr;
    public CommandSkillManager CommonSkillMgr => _commonSkillMgr;

    //进入时初始队列，队伍信息池
    private Dictionary<uint, SingleTeamCharacterInfo> m_allCharactersMap;
    private List<uint> m_allIDList;
    //上阵角色ID队列
    private List<uint> m_onFightIDList;
    //下阵角色ID队列
    private List<uint> m_waitFightIDList;
    //死亡角色ID队列
    private List<uint> m_deadIDList;
    //敌方NPCID列表
    private List<uint> m_enemyIDList;
    //载具上的成员
    private List<uint> _inVehicleIDList;

    private int _lastVehicleCellIdx = Constants.INVALID_ID;

    //当前选择ID
    private uint m_selectID = Constants.INVALID_UINT_ID;
    //战斗进行时间，战斗开始时开始计时
    private float m_fightPastTimeCount = 0;

    private bool _isChanging = false;

    private static bool _isHideAllUI = false;

    public static bool IsHideAllUI
    {
        get
        {
            return _isHideAllUI;
        }

        set
        {
            _isHideAllUI = value;
            if (_isHideAllUI)
            {
                UIManager.Instance.HideAllUI(UINameConst.UIFightScene, UINameConst.UI_Guide, UINameConst.UI_GuideTip);
            }
            else
            {
                UIManager.Instance.ShowAllUI();
            }
        }
    }

    public uint SelectID
    {
        get { return m_selectID; }
    }

    public static TeamManager Instance
    {
        get
        {
            if (m_instance == null)
            {
                m_instance = new TeamManager();
            }
            return m_instance;
        }
    }

    public async void Init()
    {
        await _Init();
    }
    private async UniTask _Init()
    {
        Team team = TeamEditManager.Instance.GetSelectTeam();
        if (SROptions.Current.UseTestTeam)
        {
            team = TeamEditManager.Instance.GetTestTeam();
        }
        if (null == team)
            _commonSkillMgr = new CommandSkillManager();
        else
            _commonSkillMgr = new CommandSkillManager(team.GetPlayerSkillIDs());

        var selectList = await GetSelectList();
        m_allIDList = new List<uint>();
        m_waitFightIDList = new List<uint>();
        m_allCharactersMap = new Dictionary<uint, SingleTeamCharacterInfo>();
        m_onFightIDList = new List<uint>();
        m_deadIDList = new List<uint>();
        m_enemyIDList = new List<uint>();
        _inVehicleIDList = new List<uint>();
        for (int i = 0; i < selectList.Count; i++)
        {
            uint uid = selectList[i].Uid;
            m_allIDList.Add(uid);
            m_allCharactersMap.Add(uid, selectList[i]);
            if (selectList[i].IsVehicle())
            {
                m_waitFightIDList.Insert(0, uid);
            }
            else
            {
                m_waitFightIDList.Add(uid);
            }
        }
    }

    private async UniTask<List<SingleTeamCharacterInfo>> GetSelectList()
    {
        //测试数据
        //AllCharacterInfo allChaInfo = AllCharacterInfo.Instance;

        var useFullCharacters = SROptions.Current.UseFullCharacters;
        var useTestTeam = SROptions.Current.UseTestTeam;

        if (useFullCharacters)
        {
            CharacterDataInfoManager.Instance.AddAllCfgCharacter();
            VehicleCultivateDataManager.Instance.AddAllCfgVehicles();
        }
        Team defaultTeam = TeamEditManager.Instance.GetSelectTeam();

        var cIDs = defaultTeam.GetAllCharacters();
        if (useFullCharacters)
        {
            cIDs = CharacterDataInfoManager.Instance.DataList.ConvertAll((info) => info.ID);
        }

        var vInfos = new List<VehicleCultivateData>();

        if (useFullCharacters)
        {
            var dataList = VehicleCultivateDataManager.Instance.DataList;
            vInfos.AddRange(dataList);
        }
        else
        {
            foreach (var vehicleID in defaultTeam.GetVehicleIDs())
            {
                if (ValueValidator.IsIdValid( vehicleID))
                {
                    var vInfo = VehicleCultivateDataManager.Instance.DataDic[ vehicleID];
                    vInfos.Add(vInfo);
                }
            }
            
        }

        if (useTestTeam)
        {
            var team = TeamEditManager.Instance.GetTestTeam();
            cIDs = team.GetAllCharacters();
            var vIDs = team.GetVehicleIDs();
            vInfos = new List<VehicleCultivateData>(VehicleCultivateDataManager.Instance.DataList.Where(
                data => vIDs.Contains(data.nID)));
        }

        List<SingleTeamCharacterInfo> selectList = new List<SingleTeamCharacterInfo>();
        int allCount = cIDs.Count + vInfos.Count;
        var count = allCount > WAIT_LIMIT ? WAIT_LIMIT : allCount;

        var workUIIndex = 1;
        //Test
        for (int i = 0; i < cIDs.Count; i++)
        {
            if (i < cIDs.Count)
            {
                var id = cIDs[i];
                if (id > 0)
                {
                    SingleTeamCharacterInfo singleInfo;
                    var charInfo = CharacterDataInfoManager.Instance.DataDic[id];
                    var unit = await GameUnitManager.instance.PrepareCharacter(charInfo, ETroopsId.Self);
                    if (unit == null)
                    {
                        DebugUtil.LogError("创建角色失败！！！");
                        continue;
                    }
                    singleInfo = new SingleTeamCharacterInfo(CharacterDataInfoManager.Instance.DataDic[id], unit.GetID());
                    unit.unitUIData.uiIndex = defaultTeam.GetCharacterIdxInAllUnits(id);
                    workUIIndex++;
                    selectList.Add(singleInfo);
                }
            }
        }

        for (int i = 0; i < vInfos.Count; i++)
        {
            if (i < vInfos.Count)
            {
                SingleTeamCharacterInfo singleInfo;
                var unit = await GameUnitManager.instance.PrepareVehicle(vInfos[i], ETroopsId.Self);
                singleInfo = new SingleTeamCharacterInfo(unit.GetID(), vInfos[i]);
                unit.unitUIData.uiIndex = defaultTeam.GetVehicleIdxInAllUnits(vInfos[i].nID);
                workUIIndex++;
                selectList.Add(singleInfo);
            }
        }

        return selectList;
    }

    private void InitData()
    {
        Release();
    }

    bool IsDead(uint uid)
    {
        if (!m_allCharactersMap.ContainsKey(uid))
        {
            DebugUtil.LogError("传入ID有误！！！");
            return false;
        }
        return m_allCharactersMap[uid].GetIsDead();
    }

    private List<uint> GetCharacterIDs()
    {
        List<uint> retList = new List<uint>();
        for (int i = 0; i < m_allIDList.Count; i++)
        {
            var id = m_allIDList[i];
            if (GetUnitType(id) == SingleTeamCharacterInfo.CharacType.Hero)
            {
                retList.Add(id);
            }
        }

        return retList;
    }

    private List<uint> GetVehicleIDs()
    {
        List<uint> retList = new List<uint>();
        for (int i = 0; i < m_allIDList.Count; i++)
        {
            var id = m_allIDList[i];
            if (GetUnitType(id) == SingleTeamCharacterInfo.CharacType.Vehicle)
            {
                retList.Add(id);
            }
        }

        return retList;
    }

    //战前上阵队列变化
    void SendWaitToFightBefore(uint toFightUId)
    {
        foreach (var uid in m_waitFightIDList)
        {
            if (toFightUId == uid)
            {
                if (GetCharacterDataInfo(uid).IsVehicle())
                {
                    m_onFightIDList.Insert(0, uid);
                }
                else
                {
                    m_onFightIDList.Add(toFightUId);
                }
                m_waitFightIDList.Remove(toFightUId);
                EventManager.Instance.Send(EventManager.EventName.LevelFightStartChange);
                return;
            }
        }
    }

    //战斗中上阵
    void SendWaitToFightFighting(uint toFightUId)
    {
        if (!m_allCharactersMap.ContainsKey(toFightUId))
        {
            return;
        }
        if (IsDead(toFightUId))
        {
            return;
        }

        foreach (var uid in m_waitFightIDList)
        {
            if (toFightUId == uid)
            {
                if (GetCharacterDataInfo(uid).IsVehicle())
                {
                    m_onFightIDList.Insert(0, uid);
                }
                else
                {
                    m_onFightIDList.Add(toFightUId);
                }
                m_waitFightIDList.Remove(toFightUId);
                //EventSystem.Instance.Send(EventSystem.EventName.LevelFightStartChange);
                return;
            }
        }
    }

    //战前下阵队列变化
    void SendFightToWaitBefore(uint toWaitUid, bool fightDontMove = true)
    {
        foreach (var uid in m_onFightIDList)
        {
            if (toWaitUid == uid)
            {
                if (GetCharacterDataInfo(uid).IsVehicle())
                {
                    m_waitFightIDList.Insert(0, uid);
                }
                else
                {
                    m_waitFightIDList.Add(toWaitUid);
                }
                m_onFightIDList.Remove(toWaitUid);
                EventManager.Instance.Send(EventManager.EventName.LevelFightStartChange);

                if (fightDontMove)
                {
                    GameUnitManager.instance.MoveUnitToPrepare(toWaitUid);
                }

                return;
            }
        }
    }

    //战斗中下阵
    void SendFightToWaitFighting(uint toWaitUid)
    {
        //LevelManager.Instance.CurrentLevel.CharacterManager.Remove(toWaitUid);
        if (!m_allCharactersMap.ContainsKey(toWaitUid))
        {
            return;
        }
        bool isDead = false;
        if (IsDead(toWaitUid) && !m_deadIDList.Contains(toWaitUid))
        {
            if (GetCharacterDataInfo(toWaitUid).IsVehicle())
            {
                m_deadIDList.Insert(0, toWaitUid);
            }
            else
            {
                m_deadIDList.Add(toWaitUid);
            }

            isDead = true;
        }

        int idx = m_onFightIDList.FindIndex((id) =>
        {
            if (m_deadIDList.Count > 0)
            {
                return m_deadIDList[0] == id;
            }
            return false;
        });
        idx = idx < 0 ? m_waitFightIDList.Count - m_deadIDList.Count : idx;

        if (isDead)
        {
            if (m_deadIDList.Count > 0)
            {
                if (m_allCharactersMap[toWaitUid].IsVehicle())
                {
                    m_waitFightIDList.Insert(idx, toWaitUid);
                    m_onFightIDList.Remove(toWaitUid);
                    return;
                }
            }
            m_waitFightIDList.Add(toWaitUid);
        }
        else
        {
            m_waitFightIDList.Insert(idx, toWaitUid);
        }

        m_onFightIDList.Remove(toWaitUid);
    }

    public void Release()
    {
        UnLoadAllPost();
        
        m_allIDList.Clear();
        m_onFightIDList.Clear();
        m_waitFightIDList.Clear();
        m_allCharactersMap.Clear();
        _inVehicleIDList.Clear();
        if (m_deadIDList != null)
        {
            m_deadIDList.Clear();
        }
        m_instance = null;
        
        //InputManager.Instance.OnFingerUp -= _OnFingerUp;
    }

    public async UniTask TeamUIInit()
    {
        await _Init();
        //InputManager.Instance.OnFingerUp += _OnFingerUp;
        
        if (LevelManager.Instance.CurrentLevel.IsPreparing())
        {
            var window = await UIManager.Instance.LoadWindow(UINameConst.UIFightScene);
            UIManager.Instance.PushWindow(window);
            window = await UIManager.Instance.LoadWindow(UINameConst.UI_StartBtn_CMSBtn);
            UIManager.Instance.PushWindow(window);
            window = await UIManager.Instance.LoadWindow(UINameConst.UITeamFight);
            UIManager.Instance.PushWindow(window);
            window = await UIManager.Instance.LoadWindow(UINameConst.UIFightClock);
            UIManager.Instance.PushWindow(window);

            AssetManager.Instance.PostPreload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UICharacterStateBar));
            AssetManager.Instance.PostPreload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UIVehicleStateBar));
            AssetManager.Instance.PostPreload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UIEnemyStateBar));
            AssetManager.Instance.PostPreload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UICharacterDamage));

            //预加载士气值图片
            AssetManager.Instance.PostPreload<Sprite>(LevelUIManager.GetMoralePic(true));
            AssetManager.Instance.PostPreload<Sprite>(LevelUIManager.GetMoralePic(false));
            //预加载数字图片
            for (int i = 0; i < 10; i++)
            {
                AssetManager.Instance.PostPreload<Sprite>(LevelUIManager.GetNumberImage(i));
            }
            for (int i = 0; i < 7; i++)
            {
                AssetManager.Instance.PostPreload<Sprite>(LevelUIManager.GetNumberImgPath(i));
            }

            var teamCharacterIDs = GetCharacterIDs();
            var vehicleIDs = GetVehicleIDs();
            for (int i = 0; i < teamCharacterIDs.Count; i++)
            {
                var uid = teamCharacterIDs[i];
                var singleData = m_allCharactersMap[uid];
                var cfg = singleData.GetConfigInfo();
                var str = CommonUtils.GetCharacterPicPath(cfg.Cfg.RoleID, CommonUtils.ECharacterPicPathType.HeadPic, (int)cfg.SkinID);//CommonUtils.GetDefaultHeadPathByUid((uint)cfg.Cfg.RoleID);
                var posterStr = CommonUtils.GetCharacterPicPath(cfg.Cfg.RoleID,CommonUtils.ECharacterPicPathType.Poster);
                AssetManager.Instance.PostPreload<Sprite>(str);
                AssetManager.Instance.PostPreload<Sprite>(posterStr);
            }

            for (int i = 0; i < vehicleIDs.Count; i++)
            {
                var uid = vehicleIDs[i];
                var singleData = m_allCharactersMap[uid];
                AssetManager.Instance.PostPreload<Sprite>(CommonUtils.GetDefaultVehicleHeadPath((uint)singleData.GetVehicleInfo().Cfg.ID));//singleData.GetVehicleInfo().Cfg.UIHeadPath
            }
            
            //预加载职业图标
            for (var i = Ejob.Job_Commander; i < Ejob.Job_Other; i++)
            {
                var path = JobHelper.GetJobSpritePathFight(i);
                AssetManager.Instance.PostPreload<Sprite>(path);
            }
            
            //预加载状态图片
            AssetManager.Instance.PostPreload<Sprite>(Constants.UI_RETREATE_STATE);
            AssetManager.Instance.PostPreload<Sprite>(Constants.UI_SUPPRESS_STATE);
            AssetManager.Instance.PostPreload<Sprite>(Constants.UI_RETREATE_STATE_MAP);
            AssetManager.Instance.PostPreload<Sprite>(Constants.UI_SUPPRESS_STATE_MAP);
            AssetManager.Instance.PostPreload<Sprite>(Constants.UI_INVEHICLE_STATE);
            
            //预加载血条Prefab
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_SELF_CHARACTER);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_SELF_VEHICLE);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_ENEMY_VEHICLE);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_SELF_SUMMON);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_SELF_PROTECTED);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_ENEMY_CHARACTER);
            AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_ENEMY_BUILDING);

            await AssetManager.Instance.WaitAllPreloads();
            
        }
    }

    public void UnLoadAllPost()
    {
        AssetManager.Instance.Unload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UICharacterStateBar), true);
        AssetManager.Instance.Unload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UIVehicleStateBar), true);
        AssetManager.Instance.Unload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UIEnemyStateBar), true);
        AssetManager.Instance.Unload(string.Format(UIManager.UI_PREFAB_PATH, UINameConst.UICharacterDamage), true);
        
        AssetManager.Instance.Unload(LevelUIManager.GetMoralePic(true), true);
        AssetManager.Instance.Unload(LevelUIManager.GetMoralePic(false), true);
        
        for (int i = 0; i < 10; i++)
        {
            AssetManager.Instance.Unload(LevelUIManager.GetNumberImage(i), true);
        }
        
        var teamCharacterIDs = GetCharacterIDs();
        var vehicleIDs = GetVehicleIDs();
        for (int i = 0; i < teamCharacterIDs.Count; i++)
        {
            var uid = teamCharacterIDs[i];
            var singleData = m_allCharactersMap[uid];
            var cfg = singleData.GetConfigInfo();
            var str = CommonUtils.GetCharacterPicPath(cfg.Cfg.RoleID, CommonUtils.ECharacterPicPathType.HeadPic, (int)cfg.SkinID);//CommonUtils.GetDefaultHeadPathByUid((uint)cfg.Cfg.RoleID);
            var posterStr = CommonUtils.GetCharacterPicPath(cfg.Cfg.RoleID,CommonUtils.ECharacterPicPathType.Poster);
            AssetManager.Instance.Unload(str);
            AssetManager.Instance.Unload(posterStr);
        }
        if (vehicleIDs.Count > 0)
        {
            var uid = vehicleIDs[0];
            var singleData = m_allCharactersMap[uid];
            AssetManager.Instance.Unload(CommonUtils.GetDefaultVehicleHeadPath((uint)singleData.GetVehicleInfo().Cfg.ID));//singleData.GetVehicleInfo().Cfg.UIHeadPath
        }
        
        AssetManager.Instance.Unload(Constants.UI_RETREATE_STATE, true);
        AssetManager.Instance.Unload(Constants.UI_SUPPRESS_STATE, true);
        AssetManager.Instance.Unload(Constants.UI_RETREATE_STATE_MAP, true);
        AssetManager.Instance.Unload(Constants.UI_SUPPRESS_STATE_MAP, true);
        AssetManager.Instance.Unload(Constants.UI_INVEHICLE_STATE, true);
    }
    
    private void _OnFingerUp(Vector2 pos)
    {
        // if (IsHideAllUI)
        // {
        //     IsHideAllUI = false;
        // }
    }

    public void TeamUIOpen()
    {
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UI_StartBtn_CMSBtn);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UITeamFight);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UIFightClock);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UIFightScene);
        
        LevelManager.Instance.CurrentLevel.Map.ShowInfo(Map.InfoMask.ShowCells, true);
        AreaManager.instance.readyAreaManager.ShowReadyArea();
    }

    public void TeamUIClose()
    {
        UIManager.Instance.CloseWindow(UINameConst.UI_StartBtn_CMSBtn);
        UIManager.Instance.CloseWindow(UINameConst.UITeamFight);
        UIManager.Instance.CloseWindow(UINameConst.UIFightClock);
        UIManager.Instance.CloseWindow(UINameConst.UIFightScene);
        LevelManager.Instance.SkillInfoClose(true);
    }

    public void SetSelectID(uint uid = Constants.INVALID_UINT_ID)
    {
        m_selectID = uid;

        bool isNeedShow = ValueValidator.IsIdValid(m_selectID);
        if (LevelManager.Instance.CurrentLevel.IsPreparing())
        {
            //AreaManager.instance.readyAreaManager.ShowReadyArea();
            // if (!isNeedShow)
            // {
            //     AreaManager.instance.readyAreaManager.HideReadyArea();
            // }
        }
        else if (LevelManager.Instance.CurrentLevel.IsInBattle())
        {
            if (m_waitFightIDList.Contains(uid))
            {
                if (GameUnitManager.instance.infightUnits.Contains(uid))
                {
                    var unit = GameUnitManager.instance.infightUnits.Search(uid);
                    if (unit.statusData.isOnVehicle)
                    {
                        // 在战斗中
                        AreaManager.instance.readyAreaManager.ShowReadyArea(EReadyAreaStatus.AroundVehicle, unit);
                    }
                }
                else if (GameUnitManager.instance.prepareUnits.Contains(uid))
                {
                    // 备战席
                    AreaManager.instance.readyAreaManager.ShowReadyArea();
                }
                else if (GameUnitManager.instance.deadUnits.Contains(uid))
                {
                    // 已死亡
                    AreaManager.instance.readyAreaManager.HideReadyArea();
                }
                else
                {
                    // 未知情况
                    DebugUtil.LogError("未知上阵情况!");
                }
            }
            else
            {
                AreaManager.instance.readyAreaManager.HideReadyArea();
            }
            
            LevelManager.Instance.CurrentLevel.Map.ShowInfo(Map.InfoMask.ShowCells, isNeedShow);
        }
        
        if (uid == Constants.INVALID_UINT_ID)
        {
            if (IsHideAllUI)
            {
                IsHideAllUI = false;
                CloseFightPosterUI();
            }
        }
    }

    //获取某一个角色的信息
    public SingleTeamCharacterInfo GetCharacterDataInfo(uint uid)
    {
        if (m_allCharactersMap.TryGetValue(uid, out var result))
        {
            return result;
        }
        return null;
    }

    //获取各个队列
    public List<uint> GetWaitList()
    {
        return m_waitFightIDList;
    }

    public List<uint> GetFightList()
    {
        return m_onFightIDList;
    }

    public List<uint> GetDeadList()
    {
        if (m_deadIDList == null)
        {
            DebugUtil.LogError("Null!");
        }
        return m_deadIDList;
    }

    public List<uint> GetInVehicleList()
    {
        return _inVehicleIDList;
    }

    public List<uint> GetEnemyList()
    {
        return m_enemyIDList;
    }

    public void AddEnemyID(uint uid)
    {
        m_enemyIDList.Add(uid);
    }

    public void ClearEnemyID(uint uid)
    {
        m_enemyIDList.Remove(uid);
    }

    public SingleTeamCharacterInfo GetSingleCharacByUid(uint uid)
    {
        return m_allCharactersMap[uid];
    }

    //上下载具
    public void InVehicleAdd(uint id)
    {
        _inVehicleIDList.Add(id);
    }

    public void InVehicleRemove(uint id)
    {
        _inVehicleIDList.Remove(id);
    }

    //选中一个准备上阵
    public void SelectToFight(uint selectUid = Constants.INVALID_UINT_ID)
    {
        SetSelectID(selectUid);
    }

    //从Level中选择的传入到UI层
    public void SelectToWait(uint selectUid = Constants.INVALID_UINT_ID)
    {
        SetSelectID(selectUid);
    }

    //上阵成功
    public void SendToFight(uint toFightUId)
    {
        if (LevelManager.Instance.CurrentLevel.IsPreparing())
        {
            SendWaitToFightBefore(toFightUId);
            return;
        }

        SendWaitToFightFighting(toFightUId);
    }

    //下阵成功
    public void SendToWait(uint toWaitUid, bool fightDontMove = true)
    {
        if (LevelManager.Instance.CurrentLevel.IsPreparing())
        {
            SendFightToWaitBefore(toWaitUid, fightDontMove);
            return;
        }

        // if (LevelManager.Instance.CurrentLevel.IsInBattle())
        // {
        SendFightToWaitFighting(toWaitUid);
        // }
    }

    //战斗时选中已上阵
    public void SelectCharacterFighting(int uid)
    {

    }

    //记录战斗开始时间
    public void StartFightTime()
    {
        //InitFightTime();
        //MonoHelper.instance.AddAction(EActionType.UPDATE, FightPassAddDeltaTime);
    }

    void FightPassAddDeltaTime()
    {
        bool isPause = LevelManager.Instance.CurrentLevel.IsPause();
        if (!isPause)
        {
            FightPastTimeAddSecond(Time.deltaTime);
        }
    }

    public void InitFightTime()
    {
        m_fightPastTimeCount = 0;
    }

    public void SetFightPastTime(float time)
    {
        m_fightPastTimeCount = time;
    }

    void FightPastTimeAddMs(float ms)
    {
        m_fightPastTimeCount += ms / 1000f;
    }

    void FightPastTimeAddSecond(float second)
    {
        m_fightPastTimeCount += second;
    }

    public float GetFightPastTime()
    {
        return m_fightPastTimeCount;
    }

    public int GetFightPastHour()
    {
        if (LevelManager.Instance.CurrentLevel == null)
        {
            return 0;
        }
        var time = LevelManager.Instance.CurrentLevel.LevelTime;
        int curTimeSecond = Convert.ToInt32(Math.Floor(time));
        int hour = Convert.ToInt32(Math.Floor(curTimeSecond / 3600f));

        return hour;
    }

    public int GetFightPastMinute()
    {
        if (LevelManager.Instance.CurrentLevel == null)
        {
            return 0;
        }
        var time = LevelManager.Instance.CurrentLevel.LevelTime;
        int curTimeSecond = Convert.ToInt32(Math.Floor(time));
        int hour = GetFightPastHour();
        int min = Convert.ToInt32(Math.Floor(curTimeSecond / 60f - hour * 60f));

        return min;
    }

    public int GetFightPastSecond()
    {
        if (LevelManager.Instance.CurrentLevel == null)
        {
            return 0;
        }
        var time = LevelManager.Instance.CurrentLevel.LevelTime;
        int curTimeSecond = Convert.ToInt32(Math.Floor(time));
        int hour = GetFightPastHour();
        int min = GetFightPastMinute();
        int sec = (curTimeSecond - min * 60 - hour * 3600);

        return sec;
    }

    public SingleTeamCharacterInfo.CharacType GetUnitType(uint uid)
    {
        if (m_allCharactersMap.ContainsKey(uid))
        {
            return m_allCharactersMap[uid].Type;
        }

        DebugUtil.LogError("请检查传入对象的类型（载具/角色）！！！uid = {0}", uid);
        return SingleTeamCharacterInfo.CharacType.Hero;
    }

    public bool IsCharacter(uint uid)
    {
        if (LevelManager.Instance.CurrentLevel.IsInBattle())
        {
            return GameUnitManager.instance.totalUnits.Search(uid).gameunitType == EGameUnitType.Character;
        }
        return GetUnitType(uid) == SingleTeamCharacterInfo.CharacType.Hero;
    }

    public bool IsVehicle(uint uid)
    {
        if (LevelManager.Instance.CurrentLevel.IsInBattle())
        {
            return GameUnitManager.instance.infightUnits.Search(uid).gameunitType == EGameUnitType.Vehicle;
        }
        return GetUnitType(uid) == SingleTeamCharacterInfo.CharacType.Vehicle;
    }

    public bool GetIsChanging()
    {
        return _isChanging;
    }

    public void SetIsChanging(bool state)
    {
        _isChanging = state;
    }

    public void BornInLevel(uint uid)
    {
        if (!m_allCharactersMap.ContainsKey(uid))
        {
            return;
        }
        m_allCharactersMap[uid].IsInLevel = true;
    }

    public void RemoveInLevel(uint uid)
    {
        if (!m_allCharactersMap.ContainsKey(uid))
        {
            return;
        }
        m_allCharactersMap[uid].IsInLevel = false;
    }

    public bool IsInLevel(uint uid)
    {
        if (!m_allCharactersMap.ContainsKey(uid))
        {
            return false;
        }

        return m_allCharactersMap[uid].IsInLevel;
    }

    public void SetIDReborn(uint uid)
    {
        if (!m_waitFightIDList.Contains(uid))
        {
            return;
        }
        if (!m_deadIDList.Contains(uid))
        {
            return;
        }

        m_waitFightIDList.Remove(uid);
        m_deadIDList.Remove(uid);
        var idx = m_waitFightIDList.Count - m_deadIDList.Count;
        m_waitFightIDList.Insert(idx, uid);
        BornInLevel(uid);
        var singleUnit = m_allCharactersMap[uid];
        singleUnit.SetIsDead();
    }
    public List<uint> GetAllIDList()
    {
        return m_allIDList;
    }

    public bool IsFightListLimit(uint uid)
    {
        return false;
        // int totalNum = 0;
        // int vehicleNum = 0;
        // var unitList = GameUnitManager.instance.infightUnits;
        // for (int i = 0; i < unitList.count; i++)
        // {
        //     var unit = unitList.GetByIndex(i);
        //     if (unit.commonData.troopId == ETroopsId.Self)
        //     {
        //         if (unit.gameunitType == EGameUnitType.Character)
        //         {
        //             ++totalNum;
        //         }
        //         if(unit.gameunitType == EGameUnitType.Vehicle)
        //         {
        //             ++vehicleNum;
        //         }
        //     }
        // }
        //
        // if (IsCharacter(uid))
        // {
        //     return totalNum >= FIGHT_LIMIT;
        // }
        //
        // return vehicleNum >= VEHICLE_FIGHT_LIMIT;
    }

    public bool IsInTeam(uint uid)
    {
        return m_allCharactersMap.ContainsKey(uid);
    }

    public bool CheckIsOnCancel()
    {
        if (UIManager.Instance.GetOpenedWindowByPath(UINameConst.UIFightPoster) is UIPosterAndSkillInfoController window)
        {
            return window.CheckIsInCancel();
        }

        return false;
    }

    public void SetCancelImageShow()
    {
        if (UIManager.Instance.GetOpenedWindowByPath(UINameConst.UIFightPoster) is UIPosterAndSkillInfoController window)
        {
            window.SetCancelShow();
        }
    }
}

//测试用，暂存一个载具信息类
public class VehicleInfo
{
    private VehicleCultivateData _vehicleData;
    private DataVehicle _cfg;
    private uint _uid;

    public DataVehicle Cfg
    {
        get => _cfg;
    }

    public uint ID
    {
        get => _uid;
    }

    public VehicleCultivateData VehicleData => _vehicleData;

    public VehicleInfo(uint id,
        DataVehicle cfg,
        VehicleCultivateData VehicleData)
    {
        _cfg = cfg;
        _uid = id;
    }
}

//单个队列中的角色信息
public class SingleTeamCharacterInfo
{
    private CharacterDataInfo _characterData;
    private VehicleCultivateData _vConfigData;

    private float m_leftBlood;
    private bool m_isDead;
    private bool _isInLevel = false; //是否被创建到战场中，没有的话不能取到各种值

    //测试数据
    private uint m_uid;         //战场中生成的UID
    private CharacType m_type;

    public readonly uint OutUid; //养成界面的UID

    public enum CharacType
    {
        Hero,
        Vehicle
    }

    public bool IsInLevel
    {
        get => _isInLevel;
        set => _isInLevel = value;
    }

    public SingleTeamCharacterInfo(CharacterDataInfo configData,
        uint uid,
        CharacType type = CharacType.Hero)
    {
        _characterData = configData;
        m_uid = uid;
        OutUid = configData.Uid;
        m_type = type;
    }

    public SingleTeamCharacterInfo(uint uid,
        VehicleCultivateData configData,
        CharacType type = CharacType.Vehicle)
    {
        _vConfigData = configData;
        //m_leftBlood = configData.Blood();
        OutUid = configData.nID;
        m_uid = uid;
        m_type = type;
    }


    public uint Uid
    {
        get { return m_uid; }
    }

    public CharacType Type
    {
        get { return m_type; }
    }

    public bool IsVehicle()
    {
        return m_type == CharacType.Vehicle;
    }

    public int GetTid()
    {
        return _characterData.Cfg.RoleID;
    }

    public CharacterDataInfo GetConfigInfo()
    {
        return _characterData;
    }

    public VehicleCultivateData GetVehicleInfo()
    {
        return _vConfigData;
    }

    public void SetType(CharacType type)
    {
        m_type = type;
    }

    //获取剩余血量
    public float GetLeftBlood()
    {
        return m_leftBlood;
    }

    public bool GetIsDead()
    {
        return m_isDead;
    }

    public void SetIsDead(bool state = false)
    {
        m_isDead = state;
    }

    //设置剩余血量
    public void SetLeftBlood(float left)
    {
        m_leftBlood = left > 0 ? left : 0;
    }
}