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

using System;
using System.Collections.Generic;
using System.Data;
using Cysharp.Threading.Tasks;
using Framework;
using Gameplay;
using Gameplay.Common;
using Gameplay.Emoji;
using Gameplay.Performance;
using Gameplay.Utils;
using PhxhSDK;
using UnityEngine;
using UnityEngine.Playables;
using Constants = Framework.Constants;

public class TeamPreviewNode: MonoBehaviour
{
    public Transform[] characterPos;
    public Transform vehiclePos;
    public Transform cRoot;
    public Transform vRoot;

    public struct CharAddData
    {
        public uint ID;
        public int Idx;
    }

    public RenderTexture RTexture => _rTexture;

    private Dictionary<int, GameObject> _characterDic;
    private GameObject _vehicleGo;

    private uint[] _charIDs;
    private uint _vehicleID;

    private bool _isLoading;
    private int _teamIdx;

    private bool _isReleasing;

    private RenderTexture _rTexture;

    private Dictionary<string, int> _assetsLoadDic = new Dictionary<string, int>();

    private List<UnitEmojiManager> _emojiMgrList = new List<UnitEmojiManager>();

    private void Awake()
    {
        EventManager.Instance.Register(EventManager.EventName.TeamEditModelCreate, (Action<CharAddData>)OnCharModelCreate);
        EventManager.Instance.Register(EventManager.EventName.TeamEditModelClear, (Action<int>)OnCharModelClear);
    }

    private void OnDestroy()
    {
        EventManager.Instance.Unregister(EventManager.EventName.TeamEditModelCreate, (Action<CharAddData>)OnCharModelCreate);
        EventManager.Instance.Unregister(EventManager.EventName.TeamEditModelClear, (Action<int>)OnCharModelClear);
        UnLoad();
        AssetManager.Instance.Unload(Constants.TEAM_EDIT_PREFAB_PATH);
    }

    public static async UniTask<TeamPreviewNode> LoadNode()
    {
        var prefab = await AssetManager.Instance.LoadAssetAsync<GameObject>(Constants.TEAM_EDIT_PREFAB_PATH);
        var go = Instantiate(prefab, Vector3.up, Quaternion.identity);
        var component = go.GetComponent<TeamPreviewNode>();
        
        return component;
    }

    public static void ReleaseNode(TeamPreviewNode node)
    {
        node.ReleaseRt();
        Destroy(node.gameObject);
    }

    private void UnLoad()
    {
        foreach (var kv in _assetsLoadDic)
        {
            var path = kv.Key;
            AssetManager.Instance.Unload(path);
        }

        foreach (var emojiMgr in _emojiMgrList)
        {
            emojiMgr.Dispose();
        }
        
        _emojiMgrList.Clear();
    }

    public void RefreshNode(int teamIdx)
    {
        var team = TeamEditManager.Instance.GetTeamByIndex((uint)teamIdx);
        var charIDs = team.GetCharacterIDs();
        var vehicleID = team.GetVehicleID();
        ClearObjs();
        SetData(teamIdx, charIDs, vehicleID);
        CreateObjs();
    }
    
    public void ClearObjs()
    {
        cRoot.transform.ClearChilds(true);
        vRoot.transform.ClearChilds(true);
        _characterDic.Clear();
    }

    public async void CreateObjs()
    {
        for (int i = 0; i < _charIDs.Length; i++)
        {
            var dataDic = CharacterDataInfoManager.Instance.DataDic;
            uint id = _charIDs[i];
            bool isValid = dataDic.ContainsKey(id);
            if (isValid)
            {
                var trans = characterPos[i];
                if (!_isLoading)
                {
                    _isLoading = true;
                    await AddCharacterGo(trans, id, i);
                }
            }
        }
        
        _isLoading = true;
        await AddVehicleGo(_vehicleID);
    }

    //初始化
    public async UniTask Init()
    {
        cRoot.transform.ClearChilds(true);
        vRoot.transform.ClearChilds(true);

        // if (!_rTexture)
        // {
        //     _rTexture = RenderTexturePool.Instance.Create("TeamPreviewNode", Screen.width,
        //         Screen.height, 32);
        //     _rTexture.name = "team_rt";
        //     // _rTexture.width = TeamEditManager.Instance.ImageSceneWidth;
        //     // _rTexture.height = TeamEditManager.Instance.ImageSceneHeight;
        // }

        var teamCamera = TeamEditCameraObj.Instance.teamEditCamera;
        teamCamera.targetTexture = _rTexture;

        _characterDic = new Dictionary<int, GameObject>();
        for (int i = 0; i < _charIDs.Length; i++)
        {
            var dataDic = CharacterDataInfoManager.Instance.DataDic;
            uint id = _charIDs[i];
            bool isValid = dataDic.ContainsKey(id);
            if (isValid)
            {
                var trans = characterPos[i];
                if (!_isLoading)
                {
                    _isLoading = true;
                    await AddCharacterGo(trans, id, i);
                }
            }
        }
        
        _isLoading = true;
        await AddVehicleGo(_vehicleID);
        
        EventManager.Instance.Send(EventManager.EventName.TeamEditPreviewInit, _rTexture);
    }

    public void CreateRt()
    {
        if (!_rTexture)
        {
            _rTexture = RenderTexturePool.Instance.Create("TeamPreviewNode", PerformanceManager.instance.fullScreenWidth,
                PerformanceManager.instance.fullScreenHeight);
        }
    }

    public void ReleaseRt()
    {
        if (_rTexture)
        {
            RenderTexturePool.Instance.Destroy(_rTexture);
            _rTexture = null;
        }
    }

    public void Clear()
    {
        for (int i = 0; i < characterPos.Length; i++)
        {
            ClearCharacterGo(i);
        }

        ClearVehicleGo();
        _rTexture.Release();
    }

    //设置数据
    public void SetData(int teamIdx, uint[] charIDs, uint vehicleID)
    {
        _teamIdx = teamIdx;
        _charIDs = (uint[])charIDs.Clone();
        _vehicleID = vehicleID;
    }

    public async UniTask LoadCharacterModel(uint id, int idx)
    {
        if (_charIDs[idx] != id)
        {
            ClearCharacterGo(idx);
            _charIDs[idx] = id;
            await AddCharacterGo(characterPos[idx], id, idx);
        }
    }

    public async UniTask LoadVehicleModel(uint id)
    {
        if (_vehicleID != id)
        {
            ClearVehicleGo();
            _vehicleID = id;
            await AddVehicleGo(id); 
        }
    }
    
    
    
    //监听事件
    private async void OnCharModelCreate(CharAddData charAddData)
    {
        await LoadCharacterModel(charAddData.ID, charAddData.Idx);
    }
    
    private void OnCharModelClear(int idx)
    {
        if (idx >= 0)
        {
            ClearCharacterGo(idx);
            return;
        }
        ClearVehicleGo();
    }
    
    /// <summary>
    /// 添加角色模型
    /// </summary>
    /// <param name="trans"></param>
    /// <param name="id"></param>
    /// <param name="idx"></param>
    async UniTask AddCharacterGo(Transform trans, uint id, int idx)
    {
        var charData = CharacterDataInfoManager.Instance.DataDic[id];
        var charCfg = charData.Cfg;
        var skinID = charData.SkinID > 0 ? (int)charData.SkinID : Constants.DEFULT_SKINID;
        var data = TableManager.Instance.Tables.SkinCfg.Get(skinID, charCfg.RoleID);
        if (data != null)
        {
            var prefabPath = PathEx.GetCharacterDisplayModelPath(data.NameID);
            var prefab = await AssetManager.Instance.LoadAssetAsync<GameObject>(prefabPath);
            _assetsLoadDic.TryAdd(prefabPath, (int)id);
            if (!trans)
            {
                return;
            }
            
            var go = Instantiate(prefab, trans.position, trans.rotation, cRoot.transform);
            if (go)
            {
                _characterDic.Add(idx, go);
                go.SetLayerEx(LayerDefine.TeamEdit);
                var anim = CommonUtils.GetChildComponent<Animator>(go);
                var playableDir = go.GetComponent<PlayableDirector>();
                if (playableDir)
                {
                    playableDir.enabled = false;
                }
                if (anim)
                {
                    if (idx < 2 || idx > 4)
                    {
                        anim.Play("standready001"); 
                    }
                    else
                    {
                        anim.Play("squatready001");
                    }
                }

                var charDataCfg = TableManager.Instance.Tables.CharacterAttri;
                if (charDataCfg.DataMap.TryGetValue((int)id, out var charSingleData))
                {
                    var emojiMgr = new UnitEmojiManager(go, charSingleData.EmojiEyesColor,
                        charSingleData.EmojiEyeBowsType, charSingleData.EmojiEyeBowsColor, -1);
                    emojiMgr.SwitchEmoji(charSingleData.DefaultDisplayEmojiId);
                    _emojiMgrList.Add(emojiMgr);
                }
                
            }
        }

        _isLoading = false;
    }

    void ClearCharacterGo(int idx)
    {
        if (_isLoading)
        {
            return;
        }

        _isLoading = true;
        if (_characterDic.TryGetValue(idx, out var go))
        {
            if (go)
            {
                DestroyImmediate(go);
                _charIDs[idx] = Team.NONE_ID;
                _characterDic.Remove(idx);
            }
        }
        _isLoading = false;
    }

    /// <summary>
    /// 载具模型加载
    /// </summary>
    /// <param name="id"></param>
    async UniTask AddVehicleGo(uint id)
    {
        var vehicleDataDic = VehicleCultivateDataManager.Instance.DataDic;
        if (vehicleDataDic.TryGetValue(id, out var vehicleData))
        {
            if (vehicleData != null)
            {
                var trans = vehiclePos;
                var prefabPath = PathEx.GetVehicleGameModelPath(vehicleData.Cfg.ID);
                var prefab = await AssetManager.Instance.LoadAssetAsync<GameObject>(prefabPath);
                _assetsLoadDic.TryAdd(prefabPath, (int)id);
                if (!trans)
                {
                    return;
                }
                var go = Instantiate(prefab, trans.position, trans.rotation, vRoot.transform);
                if (go)
                {
                    go.SetLayerEx(LayerDefine.TeamEdit);
                    go.transform.localScale = new Vector3(1.5f, 1.5f, 1.5f);
                    _vehicleGo = go;
                }
            }
        }

        _isLoading = false;
    }

    void ClearVehicleGo()
    {
        if (_isLoading)
        {
            return;
        }

        _isLoading = true;
        DestroyImmediate(_vehicleGo);
        _vehicleID = Team.NONE_ID;
        _vehicleGo = null;

        _isLoading = false;
    }
}