using System.Collections.Generic;
using ProjectBase.Res;
using ProjectBase.SingleBase;
using UnityEngine;

namespace ProjectBase.Sound
{
    /// <summary>
    /// 声音管理
    /// </summary>
    public class SoundMgr : Single<SoundMgr>
    {
        private string mBgmPath = "Audios/";
        private string mSoundPath = "Audios/";
        private AudioSource mBgm;
        private GameObject mBgmObj;
        private GameObject mSoundObj;
        private Dictionary<string, AudioSource> mSoundDict = new Dictionary<string, AudioSource>();


        /// <summary>
        /// 修改背景音乐音量
        /// </summary>
        public void SetBgmVolume(float volume)
        {
            mBgm.volume = volume;
        }

        /// <summary>
        /// 修改音效音量
        /// </summary>
        /// <param name="volume"></param>
        public void SetSoundsVolume(float volume)
        {
            foreach (var value in mSoundDict)
            {
                value.Value.volume = volume;
            }
        }

        /// <summary>
        /// 播放背景音乐
        /// </summary>
        /// <param name="name">音乐名</param>
        public void PlayNewBgm(string name)
        {
            if (mBgmObj == null)
            {
                mBgmObj = new GameObject("BgmObject");
                mBgm = mBgmObj.AddComponent<AudioSource>();
            }

            ResMgr.Instance.LoadAsync<AudioClip>(mBgmPath + name, (clip) =>
            {
                mBgm.clip = clip;
                mBgm.loop = true;
                mBgm.Stop();
                mBgm.Play();
            });
        }

        /// <summary>
        /// 继续播放当前BGM
        /// </summary>
        public void PlayBgm()
        {
            if (mBgm != null && mBgm.isPlaying)
            {
                mBgm.Play();
            }
        }

        /// <summary>
        /// 暂停当前BGM
        /// </summary>
        public void PauseBgm()
        {
            if (mBgm != null && mBgm.isPlaying)
            {
                mBgm.Pause();
            }
        }

        /// <summary>
        /// 停止播放BGM
        /// </summary>
        public void StopBgm()
        {
            if (mBgm != null && mBgm.isPlaying)
            {
                mBgm.Stop();
            }
        }


        /// <summary>
        /// 播放音效
        /// </summary>
        /// <param name="name"></param>
        /// <param name="loop"></param>
        public void PlaySound(string name, bool loop = false)
        {
            if (mSoundObj == null)
            {
                mSoundObj = new GameObject("SoundObject");
            }
            if (mSoundDict.ContainsKey(name))
            {
                mSoundDict[name].Stop();
                mSoundDict[name].Play();
            }
            else
            {
                ResMgr.Instance.LoadAsync<AudioClip>(mSoundPath + name, (clip) =>
                {
                    AudioSource audioSource = mSoundObj.AddComponent<AudioSource>();
                    mSoundDict.Add(name, audioSource);
                    audioSource.clip = clip;
                    audioSource.loop = loop;
                    audioSource.Play();
                });
            }
        }

        /// <summary>
        /// 停止播放音效
        /// </summary>
        /// <param name="name"></param>
        public void StopSound(string name)
        {
            if (mSoundDict.ContainsKey(name))
            {
                mSoundDict[name].Stop();
            }
        }

        /// <summary>
        /// 停止播放所有音效
        /// </summary>
        public void StopSounds()
        {
            foreach (var value in mSoundDict)
            {
                value.Value.Stop();
            }
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using ProjectBase.Mono;
using ProjectBase.SingleBase;
using UnityEngine;
using UnityEngine.Events;

namespace ProjectBase.Res
{
    /// <summary>
    /// AB包资源加载
    /// </summary>
    public class AbMgr : Single<AbMgr>
    {
        /// <summary>
        /// AB包字典
        /// </summary>
        Dictionary<string, AssetBundle> mAbDict = new Dictionary<string, AssetBundle>();

        /// <summary>
        /// AB包主包
        /// </summary>
        private AssetBundle mMainAb;

        /// <summary>
        /// 主包AssetBundleManifest对象
        /// </summary>
        private AssetBundleManifest mMainAbm;

        /// <summary>
        /// AB包的存放路径
        /// </summary>
        private string mPathUrl => Application.streamingAssetsPath + "/";

        /// <summary>
        /// 主包路径
        /// </summary>
        private string mMainUrl
        {
            get
            {
#if UNITY_IOS
                return "IOS"+"/";
#elif UNITY_EDITOR_OSX
                return "StandaloneOSXUniversal";
#else
                return "PC"+"/";
#endif
            }
        }

        /// <summary>
        /// 同步加载AB包
        /// </summary>
        /// <param name="abName"></param>
        /// <returns></returns>
        private AssetBundle Load(string abName)
        {
            LoadRely(abName);
            if (!mAbDict.ContainsKey(abName))
            {
                mAbDict.Add(abName, AssetBundle.LoadFromFile(mPathUrl + abName));
            }

            return mAbDict[abName];
        }

        /// <summary>
        /// 同步加载AB包依赖
        /// </summary>
        /// <param name="abName"></param>
        private void LoadRely(string abName)
        {
            if (mMainAb == null)
            {
                mMainAb = AssetBundle.LoadFromFile(mPathUrl + mMainUrl);
                mMainAbm = mMainAb.LoadAsset<AssetBundleManifest>("AssetBundleManifest");
            }

            string[] names = mMainAbm.GetAllDependencies(abName);
            foreach (var value in names)
            {
                if (mAbDict.ContainsKey(value)) continue; //如果已经加载了 就不再加载
                mAbDict.Add(value, AssetBundle.LoadFromFile(mPathUrl + value));
            }
        }

        /// <summary>
        /// 异步加载AB包
        /// </summary>
        /// <param name="abName"></param>
        /// <param name="callBack"></param>
        private void LoadAsync(string abName, UnityAction<AssetBundle> callBack)
        {
            MonoManager.Instance.StartCoroutine(IELoadAsync(abName, callBack));
        }

        /// <summary>
        /// 异步加载AB包协程
        /// </summary>
        /// <param name="abName"></param>
        /// <param name="callBack"></param>
        /// <returns></returns>
        private IEnumerator IELoadAsync(string abName, UnityAction<AssetBundle> callBack)
        {
            Coroutine coroutine = MonoManager.Instance.StartCoroutine(IELoadRelyAsync(abName));
            yield return coroutine;
            if (!mAbDict.ContainsKey(abName))
            {
                AssetBundleCreateRequest abcq = AssetBundle.LoadFromFileAsync(mPathUrl + abName);
                yield return abcq;
                if (abcq.assetBundle == null) yield break;
                mAbDict.Add(abName, abcq.assetBundle);
                callBack.Invoke(abcq.assetBundle);
                yield break;
            }

            callBack.Invoke(mAbDict[abName]);
        }

        /// <summary>
        /// 异步加载AB包依赖携程
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        private IEnumerator IELoadRelyAsync(string abName)
        {
            //异步加载主包
            if (mMainAb == null)
            {
                var abcq = AssetBundle.LoadFromFileAsync(mPathUrl + mMainUrl);
                yield return abcq;
                mMainAb = abcq.assetBundle;
                var assetBundleRequest = abcq.assetBundle.LoadAssetAsync<AssetBundleManifest>("AssetBundleManifest");
                yield return assetBundleRequest;
                mMainAbm = assetBundleRequest.asset as AssetBundleManifest;
            }

            string[] names = mMainAbm.GetAllDependencies(abName);
            foreach (var value in names)
            {
                if (mAbDict.ContainsKey(value)) continue; //如果已经加载了 就不再加载
                var request = AssetBundle.LoadFromFileAsync(mPathUrl + value);
                yield return request;
                mAbDict.Add(value, request.assetBundle);
            }
        }

        /// <summary>
        /// 同步加载AB包中的资源
        /// </summary>
        /// <param name="abName"></param>
        /// <param name="resName"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public T LoadAsset<T>(string abName, string resName) where T : Object
        {
            return !mAbDict.ContainsKey(abName) ? Load(abName).LoadAsset<T>(resName) : mAbDict[abName].LoadAsset<T>(resName);
        }

        /// <summary>
        /// 异步加载AB包中的资源
        /// </summary>
        /// <param name="abName"></param>
        /// <param name="resName"></param>
        /// <param name="callBack"></param>
        /// <typeparam name="T"></typeparam>
        public void LoadAssetAsync<T>(string abName, string resName, UnityAction<T> callBack) where T : Object
        {
            if (!mAbDict.ContainsKey(abName))
            {
                LoadAsync(abName,
                    (ab) => { MonoManager.Instance.StartCoroutine(IELoadAssetAsync(ab, resName, callBack)); });
            }
            else
            {
                MonoManager.Instance.StartCoroutine(IELoadAssetAsync(mAbDict[abName], resName, callBack));
            }
        }

        /// <summary>
        /// 异步加载AB包中的资源协程
        /// </summary>
        /// <param name="assetBundle"></param>
        /// <param name="resName"></param>
        /// <param name="callBack"></param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private IEnumerator IELoadAssetAsync<T>(AssetBundle assetBundle, string resName, UnityAction<T> callBack)
            where T : Object
        {
            var abq = assetBundle.LoadAssetAsync<T>(resName);
            yield return abq;
            if (abq.asset == null) yield break;
            callBack.Invoke(abq.asset as T);
        }

        /// <summary>
        /// 卸载AB包
        /// </summary>
        /// <param name="name"></param>
        /// <param name="unloadObjects"></param>
        public void UnLoad(string name, bool unloadObjects = false)
        {
            if (!mAbDict.ContainsKey(name)) return;
            mAbDict[name].Unload(unloadObjects);
            mAbDict.Remove(name);
        }

        /// <summary>
        /// 卸载所有ab包
        /// </summary>
        public void UnLoadAll(bool unloadObjects = false)
        {
            AssetBundle.UnloadAllAssetBundles(unloadObjects);
            mAbDict.Clear();
        }
    }
}

using System.Collections.Generic;
using ProjectBase.Res;
using ProjectBase.SingleBase;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.EventSystems;

namespace ProjectBase.UI
{
    /// <summary>
    /// UI面板层级枚举
    /// </summary>
    public enum EUiLayer
    {
        Top,
        Mid,
        Bot
    }

    /// <summary>
    /// UI面板管理器
    /// </summary>
    public class UIMgr : Single<UIMgr>
    {
        /// <summary>
        /// Canvas
        /// </summary>
        private RectTransform mCanvas;

        /// <summary>
        /// 顶层
        /// </summary>
        private Transform mTop;

        /// <summary>
        /// 中间层
        /// </summary>
        private Transform mMid;

        /// <summary>
        /// 底层
        /// </summary>
        private Transform mBot;

        /// <summary>
        /// UI路径
        /// </summary>
        private string mPath = "Prefabs/UI/UIPanel/";

        /// <summary>
        /// 面板字典
        /// </summary>
        private Dictionary<string, BasePanel> mPaelDict = new Dictionary<string, BasePanel>();

        /// <summary>
        /// 构造方法
        /// </summary>
        public UIMgr()
        {
            GameObject ui = Object.Instantiate(ResMgr.Instance.Load<GameObject>("Prefabs/UI/UI"));
            Object.DontDestroyOnLoad(ui);
            mCanvas = ui.transform.Find("Canvas").transform as RectTransform;
            mTop = GetCanvas.Find("Top");
            mMid = GetCanvas.Find("Mid");
            mBot = GetCanvas.Find("Bot");
        }

        /// <summary>
        /// 显示面板
        /// </summary>
        /// <param name="name">面板名</param>
        /// <param name="layer">面板层级</param>
        /// <typeparam name="T"></typeparam>
        public void ShowPanel<T>(string name, EUiLayer layer = EUiLayer.Mid)
            where T : BasePanel
        {
            if (mPaelDict.ContainsKey(name))
            {
                mPaelDict[name].transform.SetParent(GetLayer(layer));
                mPaelDict[name].Show();
            }
            else
            {
                //异步加载面板
                ResMgr.Instance.LoadAsync<GameObject>(mPath + name, (obj) =>
                {
                    GameObject panelObj = Object.Instantiate(obj, GetLayer(layer), false);
                    panelObj.name = obj.name; //方便UI面板下的脚本获取name
                    T panel = panelObj.GetComponent<T>();
                    mPaelDict.Add(name, panel);
                    panel.Show();
                });
            }
        }


        /// <summary>
        /// 隐藏面板
        /// </summary>
        /// <param name="name">面板名</param>
        public void HidePanel(string name)
        {
            if (!mPaelDict.ContainsKey(name)) return;
            mPaelDict[name].Hide();
            Object.Destroy(mPaelDict[name].gameObject);
            mPaelDict.Remove(name);
        }

        /// <summary>
        /// 获得Canvas
        /// </summary>
        public RectTransform GetCanvas => mCanvas;

        /// <summary>
        /// 获得面板
        /// 调用ShowPanel显示的面板才能被获取
        /// </summary>
        /// <param name="name">面板名</param>
        /// <returns></returns>
        public BasePanel GetPanel(string name) => mPaelDict.ContainsKey(name) ? mPaelDict[name] : null;


        /// <summary>
        /// 获得层级Transform
        /// </summary>
        /// <param name="layer"></param>
        /// <returns></returns>
        public Transform GetLayer(EUiLayer layer)
        {
            Transform uiLayer = null;
            switch (layer)
            {
                case EUiLayer.Top:
                    uiLayer = mTop;
                    break;
                case EUiLayer.Mid:
                    uiLayer = mMid;
                    break;
                case EUiLayer.Bot:
                    uiLayer = mBot;
                    break;
            }

            return uiLayer;
        }

        /// <summary>
        /// 添加自定义事件
        /// </summary>
        /// <param name="obj">添加事件的物体</param>
        /// <param name="type">事件类型</param>
        /// <param name="callBack">事件回调</param>
        public void AddCustomizeEventListener(GameObject obj, EventTriggerType type,
            UnityAction<BaseEventData> callBack)
        {
            EventTrigger trigger = obj.GetComponent<EventTrigger>();
            if (trigger == null)
            {
                trigger = obj.AddComponent<EventTrigger>();
            }

            foreach (var value in trigger.triggers)
            {
                if (value.eventID != type) continue;
                value.callback.AddListener(callBack);
                return;
            }

            EventTrigger.Entry entry = new EventTrigger.Entry {eventID = type};
            entry.callback.AddListener(callBack);
            trigger.triggers.Add(entry);
        }

        /// <summary>
        /// 删除自定义事件
        /// </summary>
        /// <param name="obj">添加事件的物体</param>
        /// <param name="type">事件类型</param>
        /// <param name="callBack">移除的函数</param>
        public void RemoveCustomizeEventListener(GameObject obj, EventTriggerType type,
            UnityAction<BaseEventData> callBack = null)
        {
            EventTrigger trigger = obj.GetComponent<EventTrigger>();
            if (trigger == null || trigger.triggers.Count == 0) return;
            foreach (var value in trigger.triggers)
            {
                if (value.eventID != type) continue;
                if (callBack == null)
                {
                    value.callback.RemoveAllListeners();
                }
                else
                {
                    value.callback.RemoveListener(callBack);
                }

                break;
            }
        }

        /// <summary>
        /// 屏幕坐标转局部坐标
        /// </summary>
        /// <param name="data"></param>
        /// <param name="transform"></param>
        /// <returns></returns>
        public Vector2 ScreenPointToLocalPoint(PointerEventData data, RectTransform transform)
        {
            RectTransformUtility.ScreenPointToLocalPointInRectangle(transform,
                data.position,
                data.enterEventCamera,
                out var localPos
            );
            return localPos;
        }
    }
}