2960 抢Boss活动(提交界面逻辑)

client_linchunjie

2018-08-27 d106f11e7f44c748f595da36e0cdfd54849649e6

 System/WindowBase/WindowCenter.cs

@@ -1,717 +1,718 @@
using System.Collections.Generic;
using UnityEngine;
using System;

namespace Snxxz.UI
{
    public class WindowCenter : Singleton<WindowCenter>
    {
        public event Action<Window> windowBeforeOpenEvent;
        public event Action<Window> windowAfterOpenEvent;
        public event Action<Window> windowBeforeCloseEvent;
        public event Action<Window> windowAfterCloseEvent;
        public event Action<Window> jumpWindowCloseEvent;
        List<string> closeAllIgnoreWindows = new List<string>() {
            "MessageWin", "NewBieWin", "NewItemGetWin", "AttributePromoteShowWin" ,"DungeonBeginCoolDownWin","DungeonFightWin","StatusTipWin"
            ,"ScrollTipWin","MarqueeWin","ExperienceOpenWin","TrumpetWin","BattlePrepareCoolDownWin","DungeonGradeWin"
        };

        UIRoot m_UIRoot;
        public UIRoot uiRoot {
            get {
                if (m_UIRoot == null)
                {
                    var prefab = Resources.Load<GameObject>("UI/Prefabs/UIRoot");
                    var instance = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);
                    instance.name = "UIRoot";
                    m_UIRoot = instance.GetComponent<UIRoot>();
                    if (Application.isPlaying)
                    {
                        GameObject.DontDestroyOnLoad(instance);
                    }
                }
                return m_UIRoot;
            }
        }

        WindowAsyncLoad m_AnyncLoad;
        public WindowAsyncLoad asyncLoad {
            get {
                if (m_AnyncLoad == null)
                {
                    var gameObject = new GameObject("WindowAnyncLoad");
                    m_AnyncLoad = gameObject.AddMissingComponent<WindowAsyncLoad>();
                    GameObject.DontDestroyOnLoad(gameObject);
                }

                return m_AnyncLoad;
            }
        }

        int m_PreCreateWindowNum = 0;
        public bool isPreCreating {
            get {
                return m_PreCreateWindowNum > 0;
            }
        }

        Dictionary<string, Window> windows = new Dictionary<string, Window>();

        public void OpenFromLocal<T>() where T : Window
        {
            var windowName = typeof(T).Name;
            T win = null;
            if (TryGetWindow(out win))
            {
                if (win.windowState == Window.WindowState.Closed)
                {
                    win.functionOrder = 0;
                    win.playAnimation = true;
                    win.Open();
                }
                else
                {
                    DesignDebug.Log(string.Format("{0} 窗口已经打开！", typeof(T)));
                }
            }
            else
            {
                win = GetWindowInstance<T>(true);
                if (win != null)
                {
                    win.functionOrder = 0;
                    win.playAnimation = true;
                    win.Open();
                }
            }
        }

        public T Open<T>(bool _forceSync = false, int _functionalOrder = 0) where T : Window
        {
            if (VersionConfig.Get().isBanShu)
            {
                if (typeof(T) == typeof(VipRechargeWin))
                {
                    SysNotifyMgr.Instance.ShowTip("FuncNoOpen_VIP");
                    return null;
                }
            }

            var windowName = typeof(T).Name;
            string childWindow = string.Empty;
            if (_forceSync || AssetSource.uiFromEditor)
            {
                return OpenSingleWindow<T>(_forceSync, _functionalOrder);
            }
            else
            {
                if (WindowConfig.Get().FindChildWindow(windowName, _functionalOrder, out childWindow))
                {
                    WindowTrim(childWindow);
                    if (!windows.ContainsKey(childWindow))
                    {
                        GetWindowInstanceAsync(childWindow, (bool _ok, UnityEngine.Object _object) =>
                        {
                            if (_ok)
                            {
                                OpenSingleWindow<T>(_forceSync, _functionalOrder);
                            }
                        });

                        return null;
                    }
                    else
                    {
                        return OpenSingleWindow<T>(_forceSync, _functionalOrder);
                    }
                }
                else
                {
                    return OpenSingleWindow<T>(_forceSync, _functionalOrder);
                }
            }
        }

        public T OpenWithoutAnimation<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                if (win.windowState == Window.WindowState.Closed)
                {
                    win.functionOrder = 0;
                    win.playAnimation = false;
                    win.Open();
                }
                else
                {
                    DesignDebug.Log(string.Format("{0} 窗口已经打开！", typeof(T)));
                }

                return (T)win;
            }

            win = GetWindowInstance<T>(false);
            if (win != null)
            {
                win.functionOrder = 0;
                win.playAnimation = false;
                win.Open();
            }

            return (T)win;
        }

        public T Get<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                return win;
            }
            else
            {
                DesignDebug.LogFormat("没有找到窗口:{0}", typeof(T).Name);
                return null;
            }

        }

        public Window Get(string _window)
        {
            if (windows.ContainsKey(_window))
            {
                return windows[_window];
            }
            else
            {
                return null;
            }
        }

        public T Close<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow<T>(out win))
            {
                if (win.windowState != Window.WindowState.Closed)
                {
                    win.CloseImmediately();
                }
                else
                {
                    DesignDebug.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));
                }
            }
            else
            {
                asyncLoad.StopTask(typeof(T).Name);
                DesignDebug.Log(string.Format("{0} 窗口无法获得！", typeof(T)));
            }

            return win;
        }

        public T CloseImmediately<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow<T>(out win))
            {
                if (win.windowState != Window.WindowState.Closed)
                {
                    win.CloseImmediately();
                }
                else
                {
                    DesignDebug.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));
                }
            }
            else
            {
                asyncLoad.StopTask(typeof(T).Name);
                DesignDebug.Log(string.Format("{0} 窗口无法获得！", typeof(T)));
            }

            return win;
        }

        public List<string> GetAll()
        {
            return new List<string>(windows.Keys);
        }

        public void CloseAll(CloseAllIgnoreType _ignoreType = CloseAllIgnoreType.System)
        {
            foreach (var window in windows.Values)
            {
                if (window == null)
                {
                    continue;
                }

                var isIgnore = false;
                switch (_ignoreType)
                {
                    case CloseAllIgnoreType.Base:
                        isIgnore = window.windowInfo.windowType <= WindowType.Base;
                        break;
                    case CloseAllIgnoreType.BaseAndCustom:
                        isIgnore = window.windowInfo.windowType <= WindowType.Base || closeAllIgnoreWindows.Contains(window.name);
                        break;
                    case CloseAllIgnoreType.System:
                        isIgnore = window.windowInfo.windowType >= WindowType.System;
                        break;
                    case CloseAllIgnoreType.Custom:
                        isIgnore = closeAllIgnoreWindows.Contains(window.name);
                        break;
                    case CloseAllIgnoreType.SystemAndCustom:
                        isIgnore = window.windowInfo.windowType >= WindowType.System || closeAllIgnoreWindows.Contains(window.name);
                        break;
                }

                if (!isIgnore)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        window.CloseImmediately();
                    }
                }
            }

            asyncLoad.StopAllTasks();
        }

        public void CloseOthers<T>() where T : Window
        {
            foreach (var window in windows.Values)
            {
                if (window is T)
                {
                    continue;
                }

                if (window != null)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        window.CloseImmediately();
                    }
                }
            }

            asyncLoad.StopAllTasks();

        }

        public void CloseOthers(List<string> _windowNames, CloseAllIgnoreType _ignoreType)
        {
            foreach (var window in windows.Values)
            {
                if (window == null)
                {
                    continue;
                }

                var isIgnore = false;
                switch (_ignoreType)
                {
                    case CloseAllIgnoreType.Base:
                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType <= WindowType.Base;
                        break;
                    case CloseAllIgnoreType.BaseAndCustom:
                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType <= WindowType.Base || closeAllIgnoreWindows.Contains(window.name);
                        break;
                    case CloseAllIgnoreType.System:
                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType >= WindowType.System;
                        break;
                    case CloseAllIgnoreType.Custom:
                        isIgnore = _windowNames.Contains(window.name) || closeAllIgnoreWindows.Contains(window.name);
                        break;
                    case CloseAllIgnoreType.SystemAndCustom:
                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType >= WindowType.System || closeAllIgnoreWindows.Contains(window.name);
                        break;
                }

                if (!isIgnore)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        window.CloseImmediately();
                    }
                }
            }

            asyncLoad.StopAllTasks();
        }

        public void DestoryWinsByStage(WindowStage _windowStage)
        {
            switch (_windowStage)
            {
                case WindowStage.Launch:
                    DestroyWin<DownLoadWin>();
                    DestroyWin<VersionUpdateWin>();
                    DestroyWin<LaunchWin>();
                    break;
                case WindowStage.Login:
                    DestroyWin<LoginWin>();
                    DestroyWin<ServerListWin>();
                    break;
                case WindowStage.SelectRole:
                    DestroyWin<CreateRoleWin>();
                    DestroyWin<SelectRoleWin>();
                    DestroyWin<LaunchBackGroundWin>();
                    break;
                default:
                    break;
            }

            UnLoadAssetBundle(_windowStage);
        }

        public void DestroyWin<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow<T>(out win))
            {
                win.CloseImmediately();
                GameObject.Destroy(win.gameObject);
                MonoBehaviour.Destroy(win);

                var name = typeof(T).Name;
                windows[name] = null;
                windows.Remove(typeof(T).Name);
            }
            else
            {
                DesignDebug.Log(string.Format("{0} 窗口无法获得！", typeof(T)));
            }
        }

        public void UnLoadAssetBundle(WindowStage _windowStage)
        {
            if (!AssetSource.uiFromEditor)
            {
                switch (_windowStage)
                {
                    case WindowStage.Launch:
                        break;
                    case WindowStage.Login:
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "LoginWin");
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "ServerListWin");
                        break;
                    case WindowStage.SelectRole:
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "CreateRoleWin");
                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "SelectRoleWin");
                        break;
                    default:
                        break;
                }
            }
        }

        public bool CheckOpen<T>() where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                var open = win.windowState == Window.WindowState.Opened
                               || win.windowState == Window.WindowState.Opening;

                return open;
            }
            else
            {
                return false;
            }
        }

        public bool CheckOpen(string _windowName)
        {
            if (windows.ContainsKey(_windowName) && windows[_windowName] != null)
            {
                var window = windows[_windowName];
                return window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening;
            }
            else
            {
                return false;
            }
        }

        public void PreCreateWindows()
        {
            m_PreCreateWindowNum = 0;
        }

        private void AsyncLoadWindowCallBack(bool _ok, UnityEngine.Object _object)
        {
            m_PreCreateWindowNum--;
        }

        public bool ExitAnyFullScreenOrMaskWin()
        {
            bool exit = false;
            foreach (var window in windows.Values)
            {
                if (window.windowInfo.needMask || window.windowInfo.fullScreen)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        exit = true;
                        break;
                    }
                }
            }

            return exit;
        }

        /// <summary>
        /// 是否存在大于或等于这个层级的全屏或有模糊背景的界面
        /// </summary>
        /// <param name="_windowType"></param>
        /// <returns></returns>
        public bool ExitAnyFullScreenOrMaskWinLEqual(WindowType _windowType)
        {
            bool exit = false;
            foreach (var window in windows.Values)
            {
                if ((window.windowInfo.needMask || window.windowInfo.fullScreen) && window.windowInfo.windowType >= _windowType)
                {
                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)
                    {
                        exit = true;
                        break;
                    }
                }
            }

            return exit;
        }

        internal void NotifyBeforeOpen<T>(T _window) where T : Window
        {
            if (windowBeforeOpenEvent != null)
            {
                windowBeforeOpenEvent(_window);
            }
        }

        internal void NotifyAfterOpen<T>(T _window) where T : Window
        {
            if (windowAfterOpenEvent != null)
            {
                windowAfterOpenEvent(_window);
            }
        }

        internal void NotifyBeforeClose<T>(T _window) where T : Window
        {
            if (windowBeforeCloseEvent != null)
            {
                windowBeforeCloseEvent(_window);
            }
        }

        internal void NotifyAfterClose<T>(T _window) where T : Window
        {
            if (windowAfterCloseEvent != null)
            {
                windowAfterCloseEvent(_window);
            }
        }

        internal void JumpNotifyAfterClose<T>(T _window) where T : Window
        {
            if (jumpWindowCloseEvent != null)
            {
                jumpWindowCloseEvent(_window);
            }
        }

        private T OpenSingleWindow<T>(bool _forceSync, int _functionalOrder) where T : Window
        {
            T win = null;
            if (TryGetWindow(out win))
            {
                if (win.windowState == Window.WindowState.Closed)
                {
                    win.functionOrder = _functionalOrder;
                    win.playAnimation = true;
                    win.Open();
                }
                else
                {
                    DesignDebug.Log(string.Format("{0} 窗口已经打开！", typeof(T)));
                }

                return (T)win;
            }

            if (_forceSync || AssetSource.uiFromEditor)
            {
                win = GetWindowInstance<T>(false);
                if (win != null)
                {
                    win.functionOrder = _functionalOrder;
                    win.playAnimation = true;
                    win.Open();
                }

                return (T)win;
            }
            else
            {
                GetWindowInstanceAsync<T>(
                    (bool ok, UnityEngine.Object _object) =>
                    {
                        if (TryGetWindow(out win))
                        {
                            if (win.windowState == Window.WindowState.Closed)
                            {
                                win.functionOrder = _functionalOrder;
                                win.playAnimation = true;
                                win.Open();
                            }
                            else
                            {
                                DesignDebug.Log(string.Format("{0} 窗口已经打开！", typeof(T)));
                            }
                        }
                    }
                    );

                return null;
            }
        }

        private bool TryGetWindow<T>(out T _win) where T : Window
        {
            var windowName = typeof(T).Name;
            WindowTrim(windowName);

            if (windows.ContainsKey(windowName))
            {
                _win = (T)windows[windowName];
                return true;
            }
            else
            {
                _win = null;
                return false;
            }
        }

        private void WindowTrim(string _windowName)
        {
            if (windows.ContainsKey(_windowName))
            {
                if (windows[_windowName] == null || windows[_windowName].gameObject == null)
                {
                    windows.Remove(_windowName);
                }
            }
        }

        private T GetWindowInstance<T>(bool _fromLocal) where T : Window
        {
            var prefabName = typeof(T).Name;

            if (windows.ContainsKey(prefabName))
            {
                return windows[prefabName] as T;
            }
            else
            {
                var prefab = _fromLocal ? Resources.Load<GameObject>(StringUtility.Contact("UI/Prefabs/", prefabName)) : UILoader.LoadWindow(prefabName);
                prefab.SetActive(false);
                var instance = GameObject.Instantiate(prefab);
                if (AssetSource.uiFromEditor)
                {
                    prefab.SetActive(true);
                }

                UILoader.UnLoadWindowAsset(prefabName);
                instance.name = prefabName;
                var window = instance.GetComponent<T>();
                if (window != null)
                {
                    var windowName = typeof(T).Name;
                    windows[windowName] = window;
                }
                else
                {
                    DesignDebug.LogFormat("无法获得  {0}  的资源！", prefabName);
                }

                return window;
            }

        }

        private void GetWindowInstanceAsync<T>(Action<bool, UnityEngine.Object> _callBack) where T : Window
        {
            GetWindowInstanceAsync(typeof(T).Name, _callBack);
        }

        private void GetWindowInstanceAsync(string _windowName, Action<bool, UnityEngine.Object> _callBack)
        {
            Action<bool, UnityEngine.Object> addAction = (bool _ok, UnityEngine.Object _object) =>
            {
                var prefabName = _windowName;
                Window window = null;
                if (!windows.ContainsKey(_windowName))
                {
                    var prefab = _object as GameObject;
                    prefab.SetActive(false);
                    var instance = GameObject.Instantiate(prefab);

                    if (AssetSource.uiFromEditor)
                    {
                        prefab.SetActive(true);
                    }

                    UILoader.UnLoadWindowAsset(prefabName);
                    instance.name = _windowName;
                    window = (Window)instance.GetComponent(_windowName);
                    if (window != null)
                    {
                        windows[_windowName] = (Window)window;
                    }
                    else
                    {
                        Debug.LogFormat("无法获得  {0}  的资源！", _windowName);
                    }
                }

                if (_callBack != null)
                {
                    _callBack(_ok && window != null, _object);
                }
            };

            asyncLoad.PushTask(new WindowAsyncLoad.Task(_windowName, addAction));
        }

        public enum WindowStage
        {
            Launch,
            Login,
            SelectRole,
            Other,
        }

        public enum CloseAllIgnoreType
        {
            Base = 1,
            System = 2,
            Custom = 3,
            BaseAndCustom = 4,
            SystemAndCustom = 5,
        }

    }


}
using System.Collections.Generic;

using UnityEngine;

using System;



namespace Snxxz.UI

{

    public class WindowCenter : Singleton<WindowCenter>

    {

        public event Action<Window> windowBeforeOpenEvent;

        public event Action<Window> windowAfterOpenEvent;

        public event Action<Window> windowBeforeCloseEvent;

        public event Action<Window> windowAfterCloseEvent;

        public event Action<Window> jumpWindowCloseEvent;

        List<string> closeAllIgnoreWindows = new List<string>() {

            "MessageWin", "NewBieWin", "NewItemGetWin", "AttributePromoteShowWin" ,"DungeonBeginCoolDownWin","DungeonFightWin","StatusTipWin"

            ,"ScrollTipWin","MarqueeWin","ExperienceOpenWin","TrumpetWin","BattlePrepareCoolDownWin","DungeonGradeWin","BattleHintWin",

            "TreasureDungeonMissionHintWin",

        };



        UIRoot m_UIRoot;

        public UIRoot uiRoot {

            get {

                if (m_UIRoot == null)

                {

                    var prefab = Resources.Load<GameObject>("UI/Prefabs/UIRoot");

                    var instance = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity);

                    instance.name = "UIRoot";

                    m_UIRoot = instance.GetComponent<UIRoot>();

                    if (Application.isPlaying)

                    {

                        GameObject.DontDestroyOnLoad(instance);

                    }

                }

                return m_UIRoot;

            }

        }



        WindowAsyncLoad m_AnyncLoad;

        public WindowAsyncLoad asyncLoad {

            get {

                if (m_AnyncLoad == null)

                {

                    var gameObject = new GameObject("WindowAnyncLoad");

                    m_AnyncLoad = gameObject.AddMissingComponent<WindowAsyncLoad>();

                    GameObject.DontDestroyOnLoad(gameObject);

                }



                return m_AnyncLoad;

            }

        }



        int m_PreCreateWindowNum = 0;

        public bool isPreCreating {

            get {

                return m_PreCreateWindowNum > 0;

            }

        }



        Dictionary<string, Window> windows = new Dictionary<string, Window>();



        public void OpenFromLocal<T>() where T : Window

        {

            var windowName = typeof(T).Name;

            T win = null;

            if (TryGetWindow(out win))

            {

                if (win.windowState == Window.WindowState.Closed)

                {

                    win.functionOrder = 0;

                    win.playAnimation = true;

                    win.Open();

                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                }

            }

            else

            {

                win = GetWindowInstance<T>(true);

                if (win != null)

                {

                    win.functionOrder = 0;

                    win.playAnimation = true;

                    win.Open();

                }

            }

        }



        public T Open<T>(bool _forceSync = false, int _functionalOrder = 0) where T : Window

        {

            if (VersionConfig.Get().isBanShu)

            {

                if (typeof(T) == typeof(VipRechargeWin))

                {

                    SysNotifyMgr.Instance.ShowTip("FuncNoOpen_VIP");

                    return null;

                }

            }



            var windowName = typeof(T).Name;

            string childWindow = string.Empty;

            if (_forceSync || AssetSource.uiFromEditor)

            {

                return OpenSingleWindow<T>(_forceSync, _functionalOrder);

            }

            else

            {

                if (WindowConfig.Get().FindChildWindow(windowName, _functionalOrder, out childWindow))

                {

                    WindowTrim(childWindow);

                    if (!windows.ContainsKey(childWindow))

                    {

                        GetWindowInstanceAsync(childWindow, (bool _ok, UnityEngine.Object _object) =>

                        {

                            if (_ok)

                            {

                                OpenSingleWindow<T>(_forceSync, _functionalOrder);

                            }

                        });



                        return null;

                    }

                    else

                    {

                        return OpenSingleWindow<T>(_forceSync, _functionalOrder);

                    }

                }

                else

                {

                    return OpenSingleWindow<T>(_forceSync, _functionalOrder);

                }

            }

        }



        public T OpenWithoutAnimation<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow(out win))

            {

                if (win.windowState == Window.WindowState.Closed)

                {

                    win.functionOrder = 0;

                    win.playAnimation = false;

                    win.Open();

                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                }



                return (T)win;

            }



            win = GetWindowInstance<T>(false);

            if (win != null)

            {

                win.functionOrder = 0;

                win.playAnimation = false;

                win.Open();

            }



            return (T)win;

        }



        public T Get<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow(out win))

            {

                return win;

            }

            else

            {

                DebugEx.LogFormat("没有找到窗口:{0}", typeof(T).Name);

                return null;

            }



        }



        public Window Get(string _window)

        {

            if (windows.ContainsKey(_window))

            {

                return windows[_window];

            }

            else

            {

                return null;

            }

        }



        public T Close<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow<T>(out win))

            {

                if (win.windowState != Window.WindowState.Closed)

                {

                    win.CloseImmediately();

                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));

                }

            }

            else

            {

                asyncLoad.StopTask(typeof(T).Name);

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

            }



            return win;

        }



        public T CloseImmediately<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow<T>(out win))

            {

                if (win.windowState != Window.WindowState.Closed)

                {

                    win.CloseImmediately();

                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经关闭！", typeof(T)));

                }

            }

            else

            {

                asyncLoad.StopTask(typeof(T).Name);

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

            }



            return win;

        }



        public List<string> GetAll()

        {

            return new List<string>(windows.Keys);

        }



        public void CloseAll(CloseAllIgnoreType _ignoreType = CloseAllIgnoreType.System)

        {

            foreach (var window in windows.Values)

            {

                if (window == null)

                {

                    continue;

                }



                var isIgnore = false;

                switch (_ignoreType)

                {

                    case CloseAllIgnoreType.Base:

                        isIgnore = window.windowInfo.windowType <= WindowType.Base;

                        break;

                    case CloseAllIgnoreType.BaseAndCustom:

                        isIgnore = window.windowInfo.windowType <= WindowType.Base || closeAllIgnoreWindows.Contains(window.name);

                        break;

                    case CloseAllIgnoreType.System:

                        isIgnore = window.windowInfo.windowType >= WindowType.System;

                        break;

                    case CloseAllIgnoreType.Custom:

                        isIgnore = closeAllIgnoreWindows.Contains(window.name);

                        break;

                    case CloseAllIgnoreType.SystemAndCustom:

                        isIgnore = window.windowInfo.windowType >= WindowType.System || closeAllIgnoreWindows.Contains(window.name);

                        break;

                }



                if (!isIgnore)

                {

                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)

                    {

                        window.CloseImmediately();

                    }

                }

            }



            asyncLoad.StopAllTasks();

        }



        public void CloseOthers<T>() where T : Window

        {

            foreach (var window in windows.Values)

            {

                if (window is T)

                {

                    continue;

                }



                if (window != null)

                {

                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)

                    {

                        window.CloseImmediately();

                    }

                }

            }



            asyncLoad.StopAllTasks();



        }



        public void CloseOthers(List<string> _windowNames, CloseAllIgnoreType _ignoreType)

        {

            foreach (var window in windows.Values)

            {

                if (window == null)

                {

                    continue;

                }



                var isIgnore = false;

                switch (_ignoreType)

                {

                    case CloseAllIgnoreType.Base:

                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType <= WindowType.Base;

                        break;

                    case CloseAllIgnoreType.BaseAndCustom:

                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType <= WindowType.Base || closeAllIgnoreWindows.Contains(window.name);

                        break;

                    case CloseAllIgnoreType.System:

                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType >= WindowType.System;

                        break;

                    case CloseAllIgnoreType.Custom:

                        isIgnore = _windowNames.Contains(window.name) || closeAllIgnoreWindows.Contains(window.name);

                        break;

                    case CloseAllIgnoreType.SystemAndCustom:

                        isIgnore = _windowNames.Contains(window.name) || window.windowInfo.windowType >= WindowType.System || closeAllIgnoreWindows.Contains(window.name);

                        break;

                }



                if (!isIgnore)

                {

                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)

                    {

                        window.CloseImmediately();

                    }

                }

            }



            asyncLoad.StopAllTasks();

        }



        public void DestoryWinsByStage(WindowStage _windowStage)

        {

            switch (_windowStage)

            {

                case WindowStage.Launch:

                    DestroyWin<DownLoadWin>();

                    DestroyWin<VersionUpdateWin>();

                    DestroyWin<LaunchWin>();

                    break;

                case WindowStage.Login:

                    DestroyWin<LoginWin>();

                    DestroyWin<ServerListWin>();

                    break;

                case WindowStage.SelectRole:

                    DestroyWin<CreateRoleWin>();

                    DestroyWin<SelectRoleWin>();

                    DestroyWin<LaunchBackGroundWin>();

                    break;

                default:

                    break;

            }



            UnLoadAssetBundle(_windowStage);

        }



        public void DestroyWin<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow<T>(out win))

            {

                win.CloseImmediately();

                GameObject.Destroy(win.gameObject);

                MonoBehaviour.Destroy(win);



                var name = typeof(T).Name;

                windows[name] = null;

                windows.Remove(typeof(T).Name);

            }

            else

            {

                DebugEx.Log(string.Format("{0} 窗口无法获得！", typeof(T)));

            }

        }



        public void UnLoadAssetBundle(WindowStage _windowStage)

        {

            if (!AssetSource.uiFromEditor)

            {

                switch (_windowStage)

                {

                    case WindowStage.Launch:

                        break;

                    case WindowStage.Login:

                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "LoginWin");

                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "ServerListWin");

                        break;

                    case WindowStage.SelectRole:

                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "CreateRoleWin");

                        AssetBundleUtility.Instance.UnloadAsset("ui/prioritywindow", "SelectRoleWin");

                        break;

                    default:

                        break;

                }

            }

        }



        public bool CheckOpen<T>() where T : Window

        {

            T win = null;

            if (TryGetWindow(out win))

            {

                var open = win.windowState == Window.WindowState.Opened

                               || win.windowState == Window.WindowState.Opening;



                return open;

            }

            else

            {

                return false;

            }

        }



        public bool CheckOpen(string _windowName)

        {

            if (windows.ContainsKey(_windowName) && windows[_windowName] != null)

            {

                var window = windows[_windowName];

                return window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening;

            }

            else

            {

                return false;

            }

        }



        public void PreCreateWindows()

        {

            m_PreCreateWindowNum = 0;

        }



        private void AsyncLoadWindowCallBack(bool _ok, UnityEngine.Object _object)

        {

            m_PreCreateWindowNum--;

        }



        public bool ExitAnyFullScreenOrMaskWin()

        {

            bool exit = false;

            foreach (var window in windows.Values)

            {

                if (window.windowInfo.needMask || window.windowInfo.fullScreen)

                {

                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)

                    {

                        exit = true;

                        break;

                    }

                }

            }



            return exit;

        }



        /// <summary>

        /// 是否存在大于或等于这个层级的全屏或有模糊背景的界面

        /// </summary>

        /// <param name="_windowType"></param>

        /// <returns></returns>

        public bool ExitAnyFullScreenOrMaskWinLEqual(WindowType _windowType)

        {

            bool exit = false;

            foreach (var window in windows.Values)

            {

                if ((window.windowInfo.needMask || window.windowInfo.fullScreen) && window.windowInfo.windowType >= _windowType)

                {

                    if (window.windowState == Window.WindowState.Opened || window.windowState == Window.WindowState.Opening)

                    {

                        exit = true;

                        break;

                    }

                }

            }



            return exit;

        }



        internal void NotifyBeforeOpen<T>(T _window) where T : Window

        {

            if (windowBeforeOpenEvent != null)

            {

                windowBeforeOpenEvent(_window);

            }

        }



        internal void NotifyAfterOpen<T>(T _window) where T : Window

        {

            if (windowAfterOpenEvent != null)

            {

                windowAfterOpenEvent(_window);

            }

        }



        internal void NotifyBeforeClose<T>(T _window) where T : Window

        {

            if (windowBeforeCloseEvent != null)

            {

                windowBeforeCloseEvent(_window);

            }

        }



        internal void NotifyAfterClose<T>(T _window) where T : Window

        {

            if (windowAfterCloseEvent != null)

            {

                windowAfterCloseEvent(_window);

            }

        }



        internal void JumpNotifyAfterClose<T>(T _window) where T : Window

        {

            if (jumpWindowCloseEvent != null)

            {

                jumpWindowCloseEvent(_window);

            }

        }



        private T OpenSingleWindow<T>(bool _forceSync, int _functionalOrder) where T : Window

        {

            T win = null;

            if (TryGetWindow(out win))

            {

                if (win.windowState == Window.WindowState.Closed)

                {

                    win.functionOrder = _functionalOrder;

                    win.playAnimation = true;

                    win.Open();

                }

                else

                {

                    DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                }



                return (T)win;

            }



            if (_forceSync || AssetSource.uiFromEditor)

            {

                win = GetWindowInstance<T>(false);

                if (win != null)

                {

                    win.functionOrder = _functionalOrder;

                    win.playAnimation = true;

                    win.Open();

                }



                return (T)win;

            }

            else

            {

                GetWindowInstanceAsync<T>(

                    (bool ok, UnityEngine.Object _object) =>

                    {

                        if (TryGetWindow(out win))

                        {

                            if (win.windowState == Window.WindowState.Closed)

                            {

                                win.functionOrder = _functionalOrder;

                                win.playAnimation = true;

                                win.Open();

                            }

                            else

                            {

                                DebugEx.Log(string.Format("{0} 窗口已经打开！", typeof(T)));

                            }

                        }

                    }

                    );



                return null;

            }

        }



        private bool TryGetWindow<T>(out T _win) where T : Window

        {

            var windowName = typeof(T).Name;

            WindowTrim(windowName);



            if (windows.ContainsKey(windowName))

            {

                _win = (T)windows[windowName];

                return true;

            }

            else

            {

                _win = null;

                return false;

            }

        }



        private void WindowTrim(string _windowName)

        {

            if (windows.ContainsKey(_windowName))

            {

                if (windows[_windowName] == null || windows[_windowName].gameObject == null)

                {

                    windows.Remove(_windowName);

                }

            }

        }



        private T GetWindowInstance<T>(bool _fromLocal) where T : Window

        {

            var prefabName = typeof(T).Name;



            if (windows.ContainsKey(prefabName))

            {

                return windows[prefabName] as T;

            }

            else

            {

                var prefab = _fromLocal ? Resources.Load<GameObject>(StringUtility.Contact("UI/Prefabs/", prefabName)) : UILoader.LoadWindow(prefabName);

                prefab.SetActive(false);

                var instance = GameObject.Instantiate(prefab);

                if (AssetSource.uiFromEditor)

                {

                    prefab.SetActive(true);

                }



                UILoader.UnLoadWindowAsset(prefabName);

                instance.name = prefabName;

                var window = instance.GetComponent<T>();

                if (window != null)

                {

                    var windowName = typeof(T).Name;

                    windows[windowName] = window;

                }

                else

                {

                    DebugEx.LogFormat("无法获得  {0}  的资源！", prefabName);

                }



                return window;

            }



        }



        private void GetWindowInstanceAsync<T>(Action<bool, UnityEngine.Object> _callBack) where T : Window

        {

            GetWindowInstanceAsync(typeof(T).Name, _callBack);

        }



        private void GetWindowInstanceAsync(string _windowName, Action<bool, UnityEngine.Object> _callBack)

        {

            Action<bool, UnityEngine.Object> addAction = (bool _ok, UnityEngine.Object _object) =>

            {

                var prefabName = _windowName;

                Window window = null;

                if (!windows.ContainsKey(_windowName))

                {

                    var prefab = _object as GameObject;

                    prefab.SetActive(false);

                    var instance = GameObject.Instantiate(prefab);



                    if (AssetSource.uiFromEditor)

                    {

                        prefab.SetActive(true);

                    }



                    UILoader.UnLoadWindowAsset(prefabName);

                    instance.name = _windowName;

                    window = (Window)instance.GetComponent(_windowName);

                    if (window != null)

                    {

                        windows[_windowName] = (Window)window;

                    }

                    else

                    {

                        Debug.LogFormat("无法获得  {0}  的资源！", _windowName);

                    }

                }



                if (_callBack != null)

                {

                    _callBack(_ok && window != null, _object);

                }

            };



            asyncLoad.PushTask(new WindowAsyncLoad.Task(_windowName, addAction));

        }



        public enum WindowStage

        {

            Launch,

            Login,

            SelectRole,

            Other,

        }



        public enum CloseAllIgnoreType

        {

            Base = 1,

            System = 2,

            Custom = 3,

            BaseAndCustom = 4,

            SystemAndCustom = 5,

        }



    }





}