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

using System;
using System.Collections.Generic;
using System.Linq;
using cfg.CharacterCfg;
using cfg.FightCfg;
using cfg.MonsterCfg;
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.Level.Data;
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 bool _isFightStory = true;

    //进入时初始队列，队伍信息池
    private Dictionary<uint, TeamUnitInfo> 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, UINameConst.UISkillPut);
            }
            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;
        }
    }

    #region Init

    public async void Init()
    {
        await _Init();
    }
    private async UniTask _Init()
    {
        _isFightStory = false;
        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 curLevel = LevelManager.Instance.CurrentLevel;
        if (curLevel != null)
        {
            if (curLevel.GetLevelInfo().fightStoryData != null)
            {
                _isFightStory = true;
            }
        }
        var selectList = await GetSelectList(_isFightStory);
        
        m_allIDList = new List<uint>();
        m_waitFightIDList = new List<uint>();
        m_allCharactersMap = new Dictionary<uint, TeamUnitInfo>();
        m_onFightIDList = new List<uint>();
        m_deadIDList = new List<uint>();
        m_enemyIDList = new List<uint>();
        _inVehicleIDList = new List<uint>();
        
        if (_isFightStory)
        {
            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_onFightIDList.Insert(0, uid);
                }
                else
                {
                    m_onFightIDList.Add(uid);
                }
            }

            m_onFightIDList.Reverse();
        }
        else
        {
            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<TeamUnitInfo>> GetSelectList(bool isFightStory = false)
    {
        //测试数据
        //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<TeamUnitInfo> selectList = new List<TeamUnitInfo>();
        if (isFightStory)
        {
            
            _SetTeamUnitListFightStory(selectList);
            return selectList;
        }
        
        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)
                {
                    TeamUnitInfo info;
                    var charInfo = CharacterDataInfoManager.Instance.DataDic[id];
                    var unit = await GameUnitManager.instance.PrepareCharacter(charInfo, ETroopsId.Self);
                    if (unit == null)
                    {
                        DebugUtil.LogError("创建角色失败！！！");
                        continue;
                    }
                    info = new TeamUnitInfo(CharacterDataInfoManager.Instance.DataDic[id], unit.GetID());
                    unit.unitUIData.uiIndex = defaultTeam.GetCharacterIdxInAllUnits(id);
                    unit.unitUIData.isNPC = false;
                    workUIIndex++;
                    selectList.Add(info);
                }
            }
        }

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

        return selectList;
    }

    private void InitData()
    {
        Release();
    }

    /// <summary>
    /// 剧情战斗关卡设置队伍
    /// </summary>
    /// <param name="selectList"></param>
    private void _SetTeamUnitListFightStory(List<TeamUnitInfo> selectList)
    {
        selectList.Clear();
        var level = LevelManager.Instance.CurrentLevel;
        if (level == null)
        {
            DebugUtil.LogError("当前剧情战斗关卡为空！！！无法获取上阵NPC列表");
            return;
        }

        var levelInfo = level.GetLevelInfo();
        if (levelInfo == null)
        {
            DebugUtil.LogError("当前剧情战斗关卡的关卡信息为空！！！无法获取上阵NPC列表");
            return;
        }

        var fightStoryData = levelInfo.fightStoryData;
        if (fightStoryData == null)
        {
            DebugUtil.LogError("当前剧情战斗关卡的剧情战斗相关数据为空！！！无法获取上阵NPC列表");
            return;
        }
        
        var playerTeamData = fightStoryData.playerTeamData;
        var memberList = playerTeamData.memberList;
        var infightUnits = GameUnitManager.instance.infightUnits;
        
        for (int i = 0; i < memberList.Count; i++)
        {
            var memberData = memberList[i];
            var monsterID = memberData.monsterId;
            if (monsterID == 0)
            {
                continue;
            }
            var npcMonsterData = TableManager.Instance.Tables.Monster.Get(monsterID);
            if (npcMonsterData == null)
            {
                DebugUtil.LogError($"Monster表无法获取，monsterID:{monsterID}");
                continue;
            }

            var unit = infightUnits.SearchByLocalId(memberData.unitLocalId);
            if (unit != null)
            {
                var teamUnitInfo = new TeamUnitInfo(npcMonsterData, unit.GetID());
                teamUnitInfo.SetVehicleNID((uint)npcMonsterData.MonsterClassID);
                unit.unitUIData.isNPC = true;
                selectList.Add(teamUnitInfo);
            }

            //var teamUnitInfo = new TeamUnitInfo()
        }
    }
    #endregion

    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) == TeamUnitInfo.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) == TeamUnitInfo.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;

        _isFightStory = false;
        //InputManager.Instance.OnFingerUp -= _OnFingerUp;
    }

    #region Load

    /// <summary>
    /// 初始化战斗内UI
    /// </summary>
    public async UniTask TeamUIInit()
    {
        await _Init();
        //InputManager.Instance.OnFingerUp += _OnFingerUp;

        var window = await UIManager.Instance.LoadWindow(UINameConst.UIFightScene);
        UIManager.Instance.PushWindow(window);
        window = await UIManager.Instance.LoadWindow(UINameConst.UIFightTarget);
        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);
        // window = await UIManager.Instance.LoadWindow(UINameConst.UISKillPut);
        // UIManager.Instance.PushWindow(window);   
        var skillWindow = await UISkillPutController.Open();
        skillWindow.HideWindow();
        FightSkillPutManager.Instance.SetSKillPutWindow(skillWindow);

        var storyWindow = await UIStoryFightMainController.Open();
        if (storyWindow != null)
        {
            storyWindow.HideWindow();
        }

        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);
        AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_NPC_CHARACTER);
        AssetManager.Instance.PostPreload<GameObject>(Constants.UI_STATE_BAR_NPC_VEHICLE);

        await AssetManager.Instance.WaitAllPreloads();

    }

    /// <summary>
    /// 释放加载的UI相关资源
    /// </summary>
    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;
        // }
    }

    /// <summary>
    /// 打开加载好的战斗内UI
    /// </summary>
    public void TeamUIOpen()
    {
        //UIManager.Instance.OpenLoadedNormalUI(UINameConst.UISkillPut);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UI_StartBtn_CMSBtn);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UIFightTarget);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UITeamFight);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UIFightClock);
        UIManager.Instance.OpenLoadedNormalUI(UINameConst.UIFightScene);

        var level = LevelManager.Instance.CurrentLevel;
        if (level != null)
        {
            var levelInfo = level.GetLevelInfo();
            if (levelInfo.fightStoryData != null)
            {
                EventManager.Instance.Send(EventManager.EventName.UI_FIGHT_STORY_PREPARE);
            }
        }

        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.UISkillPut);
        UIManager.Instance.CloseWindow(UINameConst.UITeamFight);
        UIManager.Instance.CloseWindow(UINameConst.UIFightClock);
        UIManager.Instance.CloseWindow(UINameConst.UIFightTarget);
        UIManager.Instance.CloseWindow(UINameConst.UIFightScene);
        LevelManager.Instance.SkillInfoClose(true);
    }

    #endregion

    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 TeamUnitInfo 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 TeamUnitInfo GetTeamUnitInfoByUid(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 TeamUnitInfo.CharacType GetUnitType(uint uid)
    {
        if (m_allCharactersMap.ContainsKey(uid))
        {
            return m_allCharactersMap[uid].Type;
        }

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

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

    public bool IsVehicle(uint uid)
    {
        if (LevelManager.Instance.CurrentLevel.IsInBattle())
        {
            return GameUnitManager.instance.infightUnits.Search(uid).gameunitType == EGameUnitType.Vehicle;
        }
        return GetUnitType(uid) == TeamUnitInfo.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 TeamUnitInfo
{
    private CharacterDataInfo _characterData;
    private VehicleCultivateData _vConfigData;
    public readonly bool IsNPC = false;
    

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

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

    public readonly uint OutUid; //养成界面的UID
    public const uint NPC_OUT_UID = 0;

    public enum CharacType
    {
        Hero,
        Vehicle
    }

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

    public TeamUnitInfo(DataMonster monsterData, uint uid)
    {
        IsNPC = true;
        if (monsterData.NpcType == ENpcType.SELF_CHARACTER)
        {
            m_type = CharacType.Hero;
            _characterData = _CreateFakeCharacterData(monsterData);
            m_uid = uid;
            OutUid = NPC_OUT_UID;
        }

        if (monsterData.NpcType == ENpcType.SELF_VEHICLE)
        {
            m_type = CharacType.Vehicle;
            m_uid = uid;
            OutUid = NPC_OUT_UID;
            _vConfigData = _CreateFakeVehicleData(monsterData);
        }
    }
    public TeamUnitInfo(CharacterDataInfo configData,
        uint uid,
        CharacType type = CharacType.Hero)
    {
        _characterData = configData;
        m_uid = uid;
        OutUid = configData.Uid;
        m_type = type;
    }

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

    private CharacterDataInfo _CreateFakeCharacterData(DataMonster monsterData)
    {
        if (monsterData.NpcType == ENpcType.SELF_CHARACTER)
        {
            var npcData = TableManager.Instance.Tables.FightNPCConfig.Get(monsterData.MonsterClassID);
            CharacterDataInfo characterDataInfo = new CharacterDataInfo();
            characterDataInfo.ID = (uint)npcData.ConfigId;      //用NPC表ID覆盖
            characterDataInfo.Level = (uint)monsterData.MonsterLevel;
            characterDataInfo.BreakLevel = 0;
            characterDataInfo.AwakeLevel = 0;
            characterDataInfo.LikelyExp = 0;
            characterDataInfo.LikelyLevel = 0;
            characterDataInfo.UltraSkillLevel = 0;
            characterDataInfo.SkinID = 1;

            var cfgTemp = TableManager.Instance.Tables.CharacterAttri.DataList[0];
            var cfg = new DataCharacterAttri(
                cfgTemp.RoleID, 
                "测试", 
                "昵称", 
                cfgTemp.BirthDay, 
                cfgTemp.StartStar, 
                cfgTemp.ExchangePiece,
                cfgTemp.ExchangeCount,
                cfgTemp.EmojiEyeBowsType,
                cfgTemp.EmojiEyesColor,
                cfgTemp.EmojiEyeBowsColor,
                cfgTemp.DefaultEmojiImgId,
                cfgTemp.DefaultDisplayEmojiId,
                npcData.StandCrossLevel,
                npcData.MoveCrossLevel,
                cfgTemp.Defence,
                cfgTemp.Hp,
                cfgTemp.Shield,
                npcData.WeaponGrasp,
                npcData.WeaponDegree,
                cfgTemp.DefenceNoMoveScale,
                npcData.Speed,
                npcData.RetreatSpeed,
                npcData.MaxMorale,
                npcData.CorrageRecover,
                npcData.CriticalRatio,
                npcData.CriticalDamage,
                npcData.WeaponId,
                cfgTemp.ShootDistanceScale,
                cfgTemp.AttackLoopCount,
                npcData.MoveShootType,
                npcData.Job,
                npcData.ProvideJob,
                cfgTemp.SpendLeadership,
                npcData.Army,
                npcData.Fraction,
                cfgTemp.FacDetail,
                cfgTemp.FacIcon
                );

            characterDataInfo.ForceSetCfg(cfg);
            return characterDataInfo;
        }
        
        DebugUtil.LogError($"创建NPC角色时出现错误！Monster NPCType不为角色！MonsterID:{monsterData.MonsterID}");
        return null;
    }

    private VehicleCultivateData _CreateFakeVehicleData(DataMonster monsterData)
    {
        if (monsterData.NpcType == ENpcType.SELF_VEHICLE)
        {
            var vehicleData = new VehicleCultivateData();
            var vehicleID = monsterData.MonsterClassID;
            var vehicleCfg = TableManager.Instance.Tables.VehicleConfig.GetOrDefault(vehicleID);
            if (vehicleCfg == null)
            {
                DebugUtil.LogError($"创建NPC载具时出现错误，无法获取配置数据！, MonsterClassID:{monsterData.MonsterClassID}");
                return null;
            }

            vehicleData.Cfg = vehicleCfg;
            return vehicleData;
        }
        
        DebugUtil.LogError($"创建NPC载具时出现错误，Monster数据不为载具！, MonsterID:{monsterData.MonsterID}");
        return null;
    }

    public void SetVehicleNID(uint nID)
    {
        if (m_type == CharacType.Vehicle)
        {
            _vConfigData.nID = nID;
        }
    }


    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 bool GetIsDead()
    {
        return m_isDead;
    }

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