Forest_Client/Forest/Assets/Scripts/Gameplay2/BuildManager.cs

using System;
using PhxhSDK;
using UnityEngine;
using System.Linq;
using LC.Newtonsoft.Json;
using Framework.Constants;
using Sirenix.OdinInspector;
using Cysharp.Threading.Tasks;
using System.Collections.Generic;
using cfg.Build;
using PhxhSDK.Phxh;
using UnityEngine.AddressableAssets;

namespace Framework.Manager
{
    /// <summary>
    /// 解锁类型
    /// </summary>
    public enum UnlockType
    {
        [LabelText("按挂点解锁")] ForGroup,

        [LabelText("按主题解锁")] ForThematic,
    }

    /// <summary>
    /// 解锁条件类型
    /// </summary>
    public enum UnlockConditionType
    {
        [LabelText("关卡解锁")] Level,

        [LabelText("金币解锁")] Coin,
    }

    [Serializable]
    public class BuildData
    {
        [ReadOnly] public string buildID;
        [LabelText("挂点数量")] public int nodeCount;
        [LabelText("主题数量")] public int thematicCount;
        [LabelText("解锁类型")] [SerializeField] public UnlockType unlockType;
        [LabelText("解锁条件类型")] [SerializeField] public UnlockConditionType unlockConditionType;
        [LabelText("解锁条件")] public List<UnlockInfo> unlockInfos;
        [LabelText("挂点数据")] public List<BuildNode> NodeInfos;

        [Serializable]
        public class UnlockInfo
        {
            [LabelText("条件")] public int condition;

            //主题 or 挂点
            [LabelText("对应组")] public int conditionGroup;

            [LabelText("前置组")] public int preGroup;
        }

        [Serializable]
        public class BuildNode
        {
            [LabelText("挂点名称")] [ReadOnly] public string Name;

            [HideInInspector] public List<string> Options;

            [HideInInspector] public string IconPath;

            [JsonConstructor]
            public BuildNode(string name)
            {
                this.Name = name;
                this.Options = new List<string>();
                this.IconPath = string.Empty;
            }

            public BuildNode()
            {
            }
        }
    }

    /// <summary>
    /// 节点信息类
    /// </summary>
    public class NodeInfo
    {
        public string Name;

        public Dictionary<string, OptionInfo> Options;

        //按挂点解锁条件
        public int Condition;

        //前置解锁组
        public string PreGroup;

        public string IconPath;

        public OptionInfo GetOptionInfo(string optionID = null)
        {
            if (optionID == null) optionID = "Option1";
            return Options.GetValueOrDefault(optionID);
        }
    }

    /// <summary>
    /// 节点选项类
    /// </summary>
    public class OptionInfo
    {
        public string Name;

        public string IconPath;

        //按主题解锁条件
        public int Condition;

        //前置主题
        public string PreThematic;
    }

    /// <summary>
    /// 每个主题节点保存信息
    /// </summary>
    public class BuildInfo
    {
        public string BuildSceneID;
        public Dictionary<string, string> ChooseNodeInfo;

        public BuildInfo()
        {
            ChooseNodeInfo = new Dictionary<string, string>();
        }

        public BuildInfo(string buildId)
        {
            BuildSceneID = buildId;
            ChooseNodeInfo = new Dictionary<string, string>();
        }
    }

    /// <summary>
    /// 玩家养成建造存盘数据
    /// </summary>
    public class UserBuildInfo
    {
        public int GuideGroup;
        public string CurBuildId;
        public Dictionary<string, BuildInfo> AllChooseNodeInfo;

        public UserBuildInfo()
        {
            AllChooseNodeInfo = new Dictionary<string, BuildInfo>();
        }

        public UserBuildInfo(string curBuildId)
        {
            CurBuildId = curBuildId;
            AllChooseNodeInfo = new Dictionary<string, BuildInfo>();
        }
    }

    public class BuildManager
    {
        private const string UserBuildSaveKey = "UserBuildInfo";
        private const string NodeName = "Node{0}";
        private const string OptionName = "Option{0}";

        private static BuildManager _instance;

        public static BuildManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new BuildManager();
                }

                return _instance;
            }
        }

        /// <summary>
        /// 玩家存盘选择信息
        /// </summary>
        public UserBuildInfo UserBuildInfo
        {
            get => _userBuildInfo;
            private set => _userBuildInfo = value;
        }

        private UserBuildInfo _userBuildInfo;

        /// <summary>
        /// 当前主题玩家选择情况
        /// </summary>
        public BuildInfo BuildInfo
        {
            get => _curBuildInfo;
            private set => _curBuildInfo = value;
        }

        private BuildInfo _curBuildInfo;

        /// <summary>
        /// 更换场景
        /// </summary>
        public bool ChangeBuildSceneID;

        /// <summary>
        /// 已达到的条件 
        /// </summary>
        public int ReachCondition { get; private set; } = -1;

        /// <summary>
        /// 当前场景蓝图
        /// </summary>
        public Sprite CurBlueprint;

        /// <summary>
        /// 当前场景顶栏图片
        /// </summary>
        public Sprite CurTopBuildUI;

        /// <summary>
        /// Build场景相机
        /// </summary>
        public Camera CurBuildCamera;

        /// <summary>
        /// 当前场景节点信息
        /// </summary>
        private Dictionary<string, NodeInfo> _nodeInfos;

        /// <summary>
        ///动态加载的图标
        /// </summary>
        private Dictionary<string, Sprite> _iconSprites;

        /// <summary>
        /// 已经加载的资源
        /// </summary>
        private readonly List<string> _loadAssets = new List<string>();

        private BuildData _curBuildData;
        private bool _isInit;
        public bool BuildInGame;

        public async UniTask LoadBuild(string buildID, int reachCondition)
        {
            InitForStorage();

            var buildConfigId = !string.IsNullOrEmpty(buildID) ? buildID : _userBuildInfo.CurBuildId;

            if (!TableManager.Instance.Tables.BuildConfig.DataMap.TryGetValue(buildConfigId, out var buildConfig))
            {
                DebugUtil.LogError("没有{0}的建造配置", buildConfigId);
                return;
            }

            if (GuideMananger.Instance.IsGuiding && !string.IsNullOrEmpty(GuideMananger.Instance.PassLevelID))
            {
                var guideCondition = int.Parse(GuideMananger.Instance.PassLevelID.Substring("level".Length));
                Instance.UpdateReachCondition(guideCondition);
            }
            else
            {
                UpdateReachCondition(reachCondition);
            }

            var buildData = await JsonHelper.LoadFromAddressable<BuildData>(buildConfig.BuildData);
            
            await Init(buildData, true);
            await Addressables.LoadSceneAsync(buildConfig.Path).ToUniTask();
            _userBuildInfo.CurBuildId = buildConfigId;
            StorageManager.Instance.SaveWithoutUpdate();
        }

        /// <summary>
        /// 获取存盘信息
        /// </summary>
        private void InitForStorage()
        {
            if (_isInit) return;
            _userBuildInfo = StorageManager.Instance.GetStorage<UserBuildInfo>(NormalConstants.UserBuildSaveKey);
            _userBuildInfo ??= new UserBuildInfo();
            if (string.IsNullOrEmpty(_userBuildInfo.CurBuildId))
            {
                _userBuildInfo.CurBuildId = TableManager.Instance.Tables.BuildConfig.DataList[0].ID;
                DebugUtil.LogError("无存盘信息, 读默认表:{0}", _userBuildInfo.CurBuildId);
            }
        }

        public async UniTask Init(BuildData buildData, bool inGame = false)
        {
            if (_isInit && !ChangeBuildSceneID) return;

            DebugUtil.LogError("当前建造ID:{0}", buildData.buildID);
            BuildInGame = inGame;
            _curBuildData = buildData;
            _nodeInfos = new Dictionary<string, NodeInfo>();
            _iconSprites = new Dictionary<string, Sprite>();

            InitNodesInfo();
            InitUserBuildInfo();
            InitCondition();
            await InitIcon();
            InitBlueprint();


            if (inGame)
                CurBuildCamera = CameraManager.Instance.UICamera;

            _isInit = true;
        }

        /// <summary>
        /// 初始化该Build场景的节点信息
        /// </summary>
        private void InitNodesInfo()
        {
            try
            {
                foreach (var node in _curBuildData.NodeInfos)
                {
                    var nodeInfo = new NodeInfo
                    {
                        Name = node.Name,
                        Options = new Dictionary<string, OptionInfo>(),
                        IconPath = node.IconPath
                    };

                    foreach (var option in node.Options)
                    {
                        var optionInfo = new OptionInfo()
                        {
                            Name = option
                        };

                        nodeInfo.Options.Add(option, optionInfo);
                    }

                    _nodeInfos.Add(nodeInfo.Name, nodeInfo);
                }
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitNodesInfo 初始化节点错误 :{0}", e);
            }
        }


        /// <summary>
        /// 初始化选择信息
        /// </summary>
        private void InitUserBuildInfo()
        {
            try
            {
                if (!BuildInGame)
                {
                    StorageManager.Instance.Init();
                    _userBuildInfo = StorageManager.Instance.GetStorage<UserBuildInfo>(UserBuildSaveKey);
                }

                if (_userBuildInfo == null)
                {
                    var buildId = _curBuildData.buildID;
                    _userBuildInfo = new UserBuildInfo(buildId);
                }

                var curBuildID = _curBuildData.buildID;
                //获取节点存盘信息
                if (!_userBuildInfo.AllChooseNodeInfo.TryGetValue(curBuildID, out var buildInfo))
                {
                    _userBuildInfo.AllChooseNodeInfo.TryAdd(curBuildID, new BuildInfo(curBuildID));
                }

                foreach (var nodeInfo in _nodeInfos)
                {
                    if (_userBuildInfo.AllChooseNodeInfo[curBuildID].ChooseNodeInfo
                        .TryGetValue(nodeInfo.Key, out var option))
                    {
                        continue;
                    }

                    _userBuildInfo.AllChooseNodeInfo[curBuildID].ChooseNodeInfo.TryAdd(nodeInfo.Key, "");
                    DebugUtil.LogError("当前场景:{0},添加了信息节点:{1},选项:{2}", curBuildID, nodeInfo.Key, "");
                }

                _curBuildInfo = _userBuildInfo.AllChooseNodeInfo[curBuildID];

                //DebugUserChooseNode();
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitUserBuildInfo 初始玩家信息错误 :{0}", e);
            }
        }

        /// <summary>
        /// 初始化条件
        /// </summary>
        private void InitCondition()
        {
            try
            {
                switch (_curBuildData.unlockType)
                {
                    case UnlockType.ForGroup:
                    {
                        foreach (var unlockInfo in _curBuildData.unlockInfos)
                        {
                            var nodeName = string.Format(NodeName, unlockInfo.conditionGroup);
                            if (_nodeInfos.TryGetValue(nodeName, out var nodeInfo))
                            {
                                nodeInfo.Condition = unlockInfo.condition;
                                var nextNode = string.Format(NodeName, unlockInfo.preGroup);
                                nodeInfo.PreGroup = nextNode;
                                //DebugUtil.LogError("挂点解锁：节点{0}的解锁条件是: {1}, 前置解锁组是: {2}", nodeInfo.Name, unlockInfo.condition, nextNode);
                            }
                        }

                        break;
                    }
                    case UnlockType.ForThematic:
                    {
                        foreach (var unlockInfo in _curBuildData.unlockInfos)
                        {
                            var optionName = string.Format(OptionName, unlockInfo.conditionGroup);
                            foreach (var nodeInfo in _nodeInfos.Values)
                            {
                                if (nodeInfo.Options.TryGetValue(optionName, out var optionInfo))
                                {
                                    optionInfo.Condition = unlockInfo.condition;

                                    var nextOption = string.Format(OptionName, unlockInfo.preGroup);
                                    optionInfo.PreThematic = nextOption;
                                    DebugUtil.LogError("主题解锁：节点{0}的选项{1}的解锁条件是:{2}, 前置解锁主题是: {3}", nodeInfo.Name,
                                        optionInfo.Name,
                                        unlockInfo.condition, nextOption);
                                }
                            }
                        }

                        break;
                    }
                }
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitCondition 初始化条件错误 :{0}", e);
            }
        }

        /// <summary>
        /// 异步加载该建造物品图标
        /// </summary>
        private async UniTask InitIcon()
        {
            try
            {
                foreach (var nodeInfo in _nodeInfos.Values)
                {
                    foreach (var optionInfo in nodeInfo.Options.Values)
                    {
                        optionInfo.IconPath = await InitOptionIcon(nodeInfo.IconPath, optionInfo.Name);
                    }
                }
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitIcon 初始化图标数据错误 :{0}", e);
            }
        }

        /// <summary>
        /// 初始化加载选项图标
        /// </summary>
        private async UniTask<string> InitOptionIcon(string iconsPath, string optionName)
        {
            try
            {
                var path = string.Format(iconsPath, optionName);
                var assetPath = path.Replace(Application.dataPath, "").Replace('\\', '/');
                var sprite = await AssetManager.Instance.LoadAssetAsync<Sprite>(assetPath);
                if (_iconSprites.TryAdd(path, sprite))
                    return path;
                return null;
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitOptionIcon 加载选项图标错误, 路径: {0}, Error: {1}", iconsPath, e);
                return null;
            }
        }

        /// <summary>
        /// 加载当前场景蓝图和对应UI
        /// </summary>
        private async void InitBlueprint()
        {
            try
            {
                var bluePath = string.Format(Constants.PathConstants.BuildBlueprint, _curBuildData.buildID);
                CurBlueprint = await AssetManager.Instance.LoadAssetAsync<Sprite>(bluePath);
                var buildUIPath = string.Format(PathConstants.BuildTopUIPath, _curBuildData.buildID);
                CurTopBuildUI = await AssetManager.Instance.LoadAssetAsync<Sprite>(buildUIPath);
                _loadAssets.Add(bluePath);
                _loadAssets.Add(buildUIPath);
            }
            catch (Exception e)
            {
                DebugUtil.LogError("BuildManager.InitBlueprint 加载蓝图错误 :{0}", e);
            }
        }

        /// <summary>
        /// 获得选项Icon图标
        /// </summary>
        public Sprite GetOptionIcon(string nodeName, string optionName)
        {
            if (_nodeInfos.TryGetValue(nodeName, out var nodeInfo))
            {
                if (nodeInfo.Options.TryGetValue(optionName, out var optionInfo))
                {
                    if (_iconSprites.TryGetValue(optionInfo.IconPath, out var sprite))
                        return sprite;
                }
            }

            return null;
        }

        /// <summary>
        /// 根据节点获得解锁条件
        /// </summary>
        public int GetCondition(string nodeName)
        {
            var condition = 0;
            if (_nodeInfos.TryGetValue(nodeName, out var nodeInfo))
            {
                condition = nodeInfo.Condition;
            }

            return condition;
        }

        /// <summary>
        /// 保存节点
        /// </summary>
        public void SaveNodeInfo(string node, string option)
        {
            if (_curBuildInfo.ChooseNodeInfo.TryGetValue(node, out var oldOption))
            {
                _curBuildInfo.ChooseNodeInfo[node] = option;
                DebugUtil.LogY($"场景{_userBuildInfo.CurBuildId}中的节点{node}保存了{option}选择");
            }
            else
            {
                DebugUtil.LogWarning("玩家Build存档信息没有 {0} 节点信息，请检查初始化", node);
                _curBuildInfo.ChooseNodeInfo.Add(node, option);
            }

            StorageManager.Instance.SaveWithoutUpdate();
        }

        /// <summary>
        /// 获取下一个解锁节点
        /// </summary>
        public string GetNextLockNode()
        {
            string nodeName = null;

            switch (_curBuildData.unlockType)
            {
                case UnlockType.ForGroup:
                {
                    foreach (var node in _nodeInfos)
                    {
                        if (_curBuildInfo.ChooseNodeInfo.TryGetValue(node.Key, out var curNode) &&
                            _curBuildInfo.ChooseNodeInfo.TryGetValue(node.Value.PreGroup, out var preNode))
                        {
                            //当前节点位选择且前置节点已选择
                            if (string.IsNullOrEmpty(curNode) && !string.IsNullOrEmpty(preNode))
                            {
                                //DebugUtil.LogError("下一个节点是{0}", node.Key);
                                return node.Key;
                            }
                        }
                    }

                    var firstNode = _nodeInfos
                        .OrderBy(kv => kv.Value.Condition)
                        .FirstOrDefault();

                    return firstNode.Key;
                }
                //TODO 按主题解锁
                default:
                    break;
            }

            //DebugUtil.LogError("得到最小的节点是{0}", nodeName);

            return nodeName;
        }

        /// <summary>
        /// 更新已经达到的条件
        /// </summary>
        public void UpdateReachCondition(int condition)
        {
            //TODO 分场景 、解锁类型、解锁条件 
            ReachCondition = condition;
        }

        /// <summary>
        /// 更新本地节点选择
        /// </summary>
        public void SetBuildUserInfo(int guideGroupID)
        {
            _userBuildInfo.GuideGroup = guideGroupID;
            StorageManager.Instance.SyncForce = true;
        }

        /// <summary>
        /// 播放音效
        /// </summary>
        public void PlaySound()
        {
            if (BuildInGame)
                AudioManager.Instance.PlaySound(AudioType.SOUND, "S_Btn",
                    new UnityAudio(false));
        }

        /// <summary>
        /// Debug 清楚玩家所有选择
        /// </summary>
        public void ClearOption()
        {
            foreach (var node in _nodeInfos)
            {
                if (_curBuildInfo.ChooseNodeInfo.TryGetValue(node.Key, out var option))
                    _curBuildInfo.ChooseNodeInfo[node.Key] = "";
            }

            DebugUserChooseNode();
            StorageManager.Instance.SyncForce = true;
        }

        private void DebugUserChooseNode()
        {
            foreach (var infos in BuildInfo.ChooseNodeInfo)
            {
                DebugUtil.LogError("节点 {0} 选择的的是 {1}", infos.Key, infos.Value);
            }
        }

        public void Release()
        {
            foreach (var icon in _iconSprites)
            {
                AssetManager.Instance.Unload(icon.Key);
            }

            foreach (var ass in _loadAssets)
            {
                AssetManager.Instance.Unload(ass);
            }
        }
    }
}