NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/Skill/SkillManager.cs

using System.Collections;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using Gameplay.Common;
using Gameplay.Vehicle.Impl;
using PhxhSDK;
using UnityEngine;

namespace Gameplay.Skill
{
    using cfg.SkillCfg;
    using Character;
    using Framework;
    using Gameplay.Buff;
    using System;

    public class SkillManager
    {

        private static SkillManager _instance;
        public static SkillManager instance
        {
            get
            {
                if (_instance == null)
                {
                    DebugUtil.LogError("Skill尚未初始化,请先初始化");
                    return null;
                }
                return _instance;
            }
        }

        public static SkillManager CreateInstance()
        {
            if (_instance != null)
            {
                DebugUtil.LogError("请勿重复创建SkillManager");
                return _instance;
            }
            _instance = new SkillManager();
            return _instance;
        }

        private List<UnitSkillManager> _handles;
        private readonly Dictionary<GameUnit, UnitSkillManager> _handleDict;

        private readonly List<EventDataUseSkill> _useSkillList;

        public bool needSkillPaused;
        public GameUnit skillingUnit;
        public readonly SkillScreenEffect screenEffect;

        private SkillManager()
        {
            _handles = new List<UnitSkillManager>();
            _handleDict = new Dictionary<GameUnit, UnitSkillManager>();
            _useSkillList = new List<EventDataUseSkill>();
            screenEffect = new SkillScreenEffect();
        }

        public void Init()
        {
            DebugUtil.Log("[Init]------SkillManager");
            screenEffect.Init();
            _RegistEvents();
        }

        private void _RegistEvents()
        {
            EventManager.Instance.Register(EventManager.EventName.UI_USE_SKILL, (Action<EventDataUseSkill>)_OnUIUseSkill);
        }

        private void _OnUIUseSkill(EventDataUseSkill eventData)
        {
            _useSkillList.Add(eventData);
        }

        private void _UnRegistEvents()
        {
            EventManager.Instance.Unregister(EventManager.EventName.UI_USE_SKILL, (Action<EventDataUseSkill>)_OnUIUseSkill);
        }

        public void Dispose()
        {
            DebugUtil.Log("[Dispose]------SkillManager");
            _UnRegistEvents();
            screenEffect.Restore();
            _handles = null;
            _instance = null;
        }

        public static DataSkill GetSkillConfigById(int skillId)
        {
            return TableManager.Instance.Tables.SkillConfig.Get(skillId);
        }

        public async UniTask<SkillLogicData> GetSkillLogicById(int logicId)
        {
            var combiePath = string.Format(Constants.SKILL_CONFIG_FORMAT_PATH, logicId);
            var loadAsset = await AssetManager.Instance.LoadAssetAsync<TextAsset>(combiePath);
            if (loadAsset == null)
            {
                DebugUtil.LogError("无效的logicId:{0}", logicId);
                return null;
            }
            var json = loadAsset.text;
            var result = JsonUtility.FromJson<SkillLogicData>(json);
            return result;
        }

        public async UniTask InitCharacter(Character charactor)
        {
            var addUnit = new UnitSkillManager(charactor);
            // 增加主动技能
            await addUnit.AddSkill(charactor.runtimeData.configData.skillId);

            _AddToManager(charactor, addUnit);
        }

        public async UniTask InitVehicle(NormalVehicle vehicle)
        {
            var addUnit = new UnitSkillManager(vehicle);
            
            // 增加主动技能
            await addUnit.AddSkill(vehicle.runtimeData.configData.skillId);
            
            _AddToManager(vehicle, addUnit);
        }

        public void RemoveCharacter(Character charactor)
        {
            if (!_handleDict.ContainsKey(charactor))
            {
                return;
            }
            var unit = _handleDict[charactor];
            _handles.Remove(unit);
            _handleDict.Remove(charactor);
        }

        private void _AddToManager(GameUnit u, UnitSkillManager unit)
        {
            _handles.Add(unit);
            _handleDict.Add(u, unit);
        }

        public UnitSkillManager GetUnitSkillManager(GameUnit unit)
        {
            if (_handleDict.TryGetValue(unit, out var result))
            {
                return result;
            }
            return null;
        }

        public void LogicUpdate(float dt)
        {
            if (_handles == null)
            {
                return;
            }

            if (needSkillPaused)
            {
                _InSkilling(dt);
            }
            else
            {
                _NoInSkilling(dt);
            }

        }

        private void _InSkilling(float dt)
        {
            if (skillingUnit.statusData.needSkillPaused)
            {
                // 等待技能使用完成
                return;
            }
            if (_useSkillList.Count > 0)
            {
                // 继续下一个
                var skillData = _useSkillList[0];
                _useSkillList.RemoveAt(0);

                var unit = GetUnitSkillManager(skillData.sender);
                unit.positiveSkill.Use(skillData.pointCellIndex);

                skillingUnit = skillData.sender;
                needSkillPaused = true;
                return;
            }
            needSkillPaused = false;

            _OnSkillEnd();
        }

        private void _NoInSkilling(float dt)
        {
            if (_useSkillList.Count > 0)
            {
                // 进行技能释放
                var skillData = _useSkillList[0];
                _useSkillList.RemoveAt(0);

                var unit = GetUnitSkillManager(skillData.sender);
                unit.positiveSkill.Use(skillData.pointCellIndex);

                skillingUnit = skillData.sender;
                needSkillPaused = skillingUnit.statusData.needSkillPaused;
            }

            if (needSkillPaused)
            {
                _OnSkillStart();
                return;
            }

            for (var i = 0; i < _handles.Count; ++i)
            {
                var handle = _handles[i];
                handle.LogicUpdate(dt);
            }
        }

        private void _OnSkillEnd()
        {
            screenEffect.Hide();

            EventManager.Instance.Send(EventManager.EventName.INFIGHT_SKILL_END_PAUSE);
        }

        private void _OnSkillStart()
        {
            screenEffect.Show();

            EventManager.Instance.Send(EventManager.EventName.INFIGHT_SKILL_START_PAUSE);
        }



    }

}