2、WindowManager源码分析--最后一战

在最后一站中，几乎所有的UI界面都是这个WindowManager管理的，那么他是如何调度的呢？我们来看看一些项目中的界面。

上面有登陆界面，专门管理登陆。战斗界面，用户界面，专门管理用户属性等等。

既然UI有分类型，那么我们要设计不同类型的UI类，每个类负责自己的功能。

然后WindowManager管理这些不同类型的UI类。

虽然UI有着不同的类型，但是他们本质都是一样的，都是界面，所以我们设计一个界面父类，你看每个界面都根目录吧，都有自己的名字吧，都可以打开关闭吧，都要有事件监听吧。

所以最后一站抽象出了一个UI抽象基类，WindowBase.cs

接下来我们来分析一下类图和其中重点代码！

---

BaseWindow.cs

---

 using UnityEngine;
 using System.Collections;
 using BlGame;
 using GameDefine;

 namespace BlGame.View
 {
     /// <summary>
     /// 抽象出来一个UI抽象基类，每一个窗口都有自己的属性方法字段等等
     /// </summary>
     public abstract class BaseWindow
     {
         protected Transform mRoot;          //UI根目录

         protected EScenesType mScenesType; //场景类型
         protected string mResName;         //资源名
         protected bool mResident;          //是否常驻
         protected bool mVisible = false;   //是否可见
         #region 这里面的抽象方法都需要子类自己实现

         //类对象初始化
         public abstract void Init();

         //类对象释放
         public abstract void Realse();

         //窗口控制初始化
         protected abstract void InitWidget();

         //窗口控件释放
         protected abstract void RealseWidget();

         //游戏事件注册
         protected abstract void OnAddListener();

         //游戏事件注消
         protected abstract void OnRemoveListener();

         //显示初始化
         public abstract void OnEnable();

         //隐藏处理
         public abstract void OnDisable();

         //每帧更新
         public virtual void Update(float deltaTime) { }

         #endregion

         #region 基类自己的方法，子类也可以用，因为子类是继承父类的，父类的属性方法都会被继承

         //取得场景类型
         public EScenesType GetScenseType()
         {
             return mScenesType;
         }

         //是否已打开
         public bool IsVisible() { return mVisible; }

         //是否常驻内存
         public bool IsResident() { return mResident; }

         //显示
         public void Show()
         {
             if (mRoot == null)
             {
                 if (Create())
                 {
                     InitWidget();
                 }
             }

             if (mRoot && mRoot.gameObject.activeSelf == false)
             {
                 mRoot.gameObject.SetActive(true);

                 mVisible = true;

                 OnEnable();

                 OnAddListener();
             }
         }

         //隐藏
         public void Hide()
         {
             if (mRoot && mRoot.gameObject.activeSelf == true)
             {
                 OnRemoveListener();
                 OnDisable();

                 if (mResident)
                 {
                     mRoot.gameObject.SetActive(false);//如果是常驻内存直接隐藏，不销毁
                 }
                 else
                 {
                     RealseWidget();
                     Destroy();
                 }
             }

             mVisible = false;
         }

         //预加载
         public void PreLoad()
         {
             if (mRoot == null)
             {
                 if (Create())
                 {
                     InitWidget();
                 }
             }
         }

         //延时删除
         public void DelayDestory()
         {
             if (mRoot)
             {
                 RealseWidget();
                 Destroy();
             }
         }

         //创建窗体
         private bool Create()
         {
             if (mRoot)
             {
                 Debug.LogError("Window Create Error Exist!");
                 return false;
             }

             if (mResName == null || mResName == "")
             {
                 Debug.LogError("Window Create Error ResName is empty!");
                 return false;
             }

             if (GameMethod.GetUiCamera.transform == null)
             {
                 Debug.LogError("Window Create Error GetUiCamera is empty! WindowName = " + mResName);
                 return false;
             }

             GameObject obj = LoadUiResource.LoadRes(GameMethod.GetUiCamera.transform, mResName);

             if (obj == null)
             {
                 Debug.LogError("Window Create Error LoadRes WindowName = " + mResName);
                 return false;
             }

             mRoot = obj.transform;

             mRoot.gameObject.SetActive(false);

             return true;
         }

         //销毁窗体
         protected void Destroy()
         {
             if (mRoot)
             {
                 LoadUiResource.DestroyLoad(mRoot.gameObject);
                 mRoot = null;
             }
         }

         //取得根节点
         public Transform GetRoot()
         {
             return mRoot;
         }

     }
         #endregion

 }

---

LoginWindow .cs

 using UnityEngine;
 using System.Collections;
 using System.Collections.Generic;
 using JT.FWW.GameData;
 using GameDefine;
 using UICommon;
 using BlGame;
 using BlGame.GameData;
 using BlGame.Network;
 using System.Linq;
 using BlGame.Ctrl;

 namespace BlGame.View
 {
     /// <summary>
     /// 1、这里运用到了里斯替换原则，父类出现得地方，子类都可以出现，但是反过来就不行
     /// 2、例如BaseWindow login = new LoginWindow();这段代码是正确的，而 LoginWindow login = new BaseWindow();就无法创建
     /// 3、这样的好处：子类可以有自己的个性，也可以继承父类的方法和属性，比如loginWindow就可以用来处理登录功能，而BattleWindow就可以专门用于处理战斗模块
     /// </summary>
     public class LoginWindow : BaseWindow
     {
         /// <summary>
         /// 在子类的构造函数中，我们先初始化父类的属性
         /// </summary>
         public LoginWindow()
         {
             mScenesType = EScenesType.EST_Login;//场景类型
             mResName = GameConstDefine.LoadGameLoginUI;
             mResident = false;
         }

         ////////////////////////////继承接口/////////////////////////

         //类对象初始化
         /// <summary>
         /// 在初始化方法里面，它添加了委托监听事件show（）和hide（）
         /// 这里面的EventCenter是个什么呢？最初呢！我认为是不是一个框架里面东西呢？
         /// 比如StrangeIOC框架里面的全局dispatcher（事件中间者）
         /// 看了大神的解释：这里的eventcenter就是事件中介者，比如你想在进入登录状态的时候显示登录UI。
         /// 你要先注册show（）显示UI事件到事件中介者那边，然后当进入登录状态的时候，触发这个委托事件，就执行show（）
         /// 方法，UI就会被显示。
         /// </summary>
         public override void Init()
         {
             EventCenter.AddListener(EGameEvent.eGameEvent_LoginEnter, Show);
             EventCenter.AddListener(EGameEvent.eGameEvent_LoginExit, Hide);
         }

         //类对象释放
         public override void Realse()
         {
             EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginEnter, Show);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginExit, Hide);
         }

         //窗口控件初始化
        /// <summary>
        /// 初始化各个组件，比如Button这些
        /// </summary>
         protected override void InitWidget()
         {
             mLoginParent = mRoot.FindChild("Server_Choose");
             mLoginInput = mRoot.FindChild("Server_Choose/Loginer");
             mLoginSubmit = mRoot.FindChild("Server_Choose/Button");
             mLoginAccountInput = mRoot.FindChild("Server_Choose/Loginer/AcountInput").GetComponent<UIInput>();
             mLoginPassInput = mRoot.FindChild("Server_Choose/Loginer/PassInput").GetComponent<UIInput>();

             mPlayParent = mRoot.Find("LoginBG");
             mPlaySubmitBtn = mRoot.Find("LoginBG/LoginBtn");
             mPlayServerBtn = mRoot.Find("LoginBG/CurrentSelection");
             mPlayNameLabel = mRoot.FindChild("LoginBG/CurrentSelection/Label3").GetComponent<UILabel>();
             mPlayStateLabel = mRoot.FindChild("LoginBG/CurrentSelection/Label4").GetComponent<UILabel>();
             mPlayAnimate = mPlaySubmitBtn.GetComponent<Animator>();

             mChangeAccountBtn = mRoot.FindChild("ChangeAccount");
             mChangeAccountName = mRoot.FindChild("ChangeAccount/Position/Label1").GetComponent<UILabel>();

             mServerParent = mRoot.FindChild("UIGameServer");

             mReLoginParent = mRoot.FindChild("LogInAgain");
             mReLoginSubmit = mRoot.FindChild("LogInAgain/Status1/Button");

             mVersionLable = mRoot.FindChild("Label").GetComponent<UILabel>();
             mWaitingParent = mRoot.FindChild("Connecting");

             UIEventListener.Get(mPlaySubmitBtn.gameObject).onClick += OnPlaySubmit;
             UIEventListener.Get(mPlayServerBtn.gameObject).onClick += OnPlayServer;

             UIEventListener.Get(mChangeAccountBtn.gameObject).onClick += OnChangeAccount;

             UIEventListener.Get(mReLoginSubmit.gameObject).onClick += OnReLoginSubmit;

             UIEventListener.Get(mLoginSubmit.gameObject).onClick += OnLoginSubmit;

             mServerList.Clear();
             for (int i = ; i < ; i++)
             {
                 UIToggle toggle = mLoginParent.FindChild("Server" + (i + ).ToString()).GetComponent<UIToggle>();
                 mServerList.Add(toggle);
             }

             for (int i = ; i < mServerList.Count; i++)
             {
                 EventDelegate.Add(mServerList.ElementAt(i).onChange, OnSelectIp);
             }

             DestroyOtherUI();
         }

         //删除Login外其他控件，例如
         public static void DestroyOtherUI()
         {
             Camera camera = GameMethod.GetUiCamera;
             for (int i = ; i < camera.transform.childCount; i++)
             {
                 if (camera.transform.GetChild(i) != null && camera.transform.GetChild(i).gameObject != null)
                 {

                     GameObject obj = camera.transform.GetChild(i).gameObject;
                     if (obj.name != "UIGameLogin(Clone)")
                     {
                         GameObject.DestroyImmediate(obj);
                     }
                 }
             }
         }

         //窗口控件释放
         protected override void RealseWidget()
         {
         }

         //游戏事件注册
         protected override void OnAddListener()
         {
             EventCenter.AddListener<EErrorCode>(EGameEvent.eGameEvent_LoginError, LoginFail);//登錄反饋
             EventCenter.AddListener(EGameEvent.eGameEvent_LoginSuccess, LoginSuceess);
             EventCenter.AddListener<string,string>(EGameEvent.eGameEvent_SdkRegisterSuccess, SdkRegisterSuccess);//sdk register success
             EventCenter.AddListener(EGameEvent.eGameEvent_SdkServerCheckSuccess, SdkServerCheckSuccess);//sdk register success
             EventCenter.AddListener(EGameEvent.eGameEvent_SelectServer, SelectServer);//选择了服务器
             EventCenter.AddListener(EGameEvent.eGameEvent_LoginFail, ShowLoginFail);
             EventCenter.AddListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff);
         }

         //游戏事件注消
         protected override void OnRemoveListener()
         {
             EventCenter.RemoveListener<EErrorCode>(EGameEvent.eGameEvent_LoginError, LoginFail);
             EventCenter.RemoveListener<string,string>(EGameEvent.eGameEvent_SdkRegisterSuccess, SdkRegisterSuccess);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_SdkServerCheckSuccess, SdkServerCheckSuccess);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_SelectServer, SelectServer);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginFail, ShowLoginFail);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_LoginSuccess, LoginSuceess);
             EventCenter.RemoveListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff);
         }

         //显示
         public override void OnEnable()
         {
             mVersionLable.text = SdkConector.GetBundleVersion();
             mPlayAnimate.enabled = true;
             ShowServer(LOGINUI.None);

 #if UNITY_STANDALONE_WIN || UNITY_EDITOR || SKIP_SDK
             mLoginInput.gameObject.SetActive(true);
 #endif
         }

         //隐藏
         public override void OnDisable()
         {
         }

         ////////////////////////////////UI事件响应////////////////////////////////////

         void OnPlaySubmit(GameObject go)
         {
             mWaitingParent.gameObject.SetActive(true);
             UIEventListener.Get(mPlaySubmitBtn.gameObject).onClick -= OnPlaySubmit;

             LoginCtrl.Instance.GamePlay();
         }

         void OnPlayServer(GameObject go)
         {
             ShowServer(LOGINUI.SelectServer);
         }

         void OnChangeAccount(GameObject go)
         {
             LoginCtrl.Instance.SdkLogOff();
         }

         void OnReLoginSubmit(GameObject go)
         {
             mReLoginParent.gameObject.SetActive(false);

             LoginCtrl.Instance.SdkLogOff();
         }

         void OnLoginSubmit(GameObject go)
         {
 #if UNITY_STANDALONE_WIN
             if (string.IsNullOrEmpty(mLoginAccountInput.value))
                 return;
             mLoginPassInput.value = "";
 #else
            if (string.IsNullOrEmpty(mLoginAccountInput.value) || string.IsNullOrEmpty(mLoginPassInput.value))
                 return;
 #endif

             mWaitingParent.gameObject.SetActive(true);

             LoginCtrl.Instance.Login(mLoginAccountInput.value, mLoginPassInput.value);
         }

         void OnSelectIp()
         {
             if (UIToggle.current == null || !UIToggle.current.value)
                 return;
             for (int i = ; i < mServerList.Count; i++)
             {
                 if (mServerList.ElementAt(i) == UIToggle.current)
                 {
                     LoginCtrl.Instance.SelectLoginServer(i);
                     break;
                 }
             }
         }

         ////////////////////////////////游戏事件响应////////////////////////////////////

         //登录失败
         void LoginFail(EErrorCode errorCode)
         {
             mPlayAnimate.enabled = true;

             mPlaySubmitBtn.gameObject.SetActive(true);
             GameObject.DestroyImmediate(mPlayEffect.gameObject);
         }

         //登陆失败反馈
         void ShowLoginFail()
         {
             mReLoginParent.gameObject.SetActive(true);
             mWaitingParent.gameObject.SetActive(false);
             UIEventListener.Get(mPlaySubmitBtn.gameObject).onClick += OnPlaySubmit;
         }

         //登陆成功
         void LoginSuceess()
         {
             UIEventListener.Get(mPlaySubmitBtn.gameObject).onClick -= OnPlaySubmit;
         }

         //选择了服务器
         void SelectServer()
         {
             ShowSelectServerInfo();
             ShowServer(LOGINUI.Login);
         }

         //显示服务器信息或者显示登录信息
         void ShowServer(LOGINUI state)
         {
             bool showLogin = false;
             bool showServer = false;
             bool showSelectServer = false;
             switch (state)
             {
                 case LOGINUI.Login:
                     ShowSelectServerInfo();
                     showLogin = true;
                     showServer = false;
                     showSelectServer = false;
                     break;
                 case LOGINUI.SelectServer:
                     showLogin = false;
                     showServer = true;
                     showSelectServer = false;
                     break;
                 case LOGINUI.None:
                     showLogin = false;
                     showServer = false;
 #if UNITY_STANDALONE_WIN || UNITY_EDITOR || SKIP_SDK
                     showSelectServer = true;
 #endif
                     break;
             }
             mPlayParent.gameObject.SetActive(showLogin);
             mServerParent.gameObject.SetActive(showServer);
             mLoginParent.gameObject.SetActive(showSelectServer);
             if (showLogin)
             {
 #if UNITY_STANDALONE_WIN || UNITY_EDITOR|| SKIP_SDK
                 mChangeAccountName.text = mLoginAccountInput.value;
 #else
                 mChangeAccountName.text = SdkConector.NickName();
 #endif
             }
             mChangeAccountBtn.gameObject.SetActive(showLogin);
         }

         //显示选中的server信息
         void ShowSelectServerInfo()
         {
             SelectServerData.ServerInfo info = SelectServerData.Instance.curSelectServer;
             mPlayNameLabel.text = info.name;
             mPlayStateLabel.text = "(" + SelectServerData.Instance.StateString[(int)info.state] + ")";
             SelectServerData.Instance.SetLabelColor(mPlayStateLabel, info.state);
         }

         //SDK注册成功
         void SdkRegisterSuccess(string uid, string sessionId)
         {
             LoginCtrl.Instance.SdkRegisterSuccess(uid, sessionId);

             mWaitingParent.gameObject.SetActive(true);
         }

         //SDK检查成功
         void SdkServerCheckSuccess()
         {
             ShowServer(LOGINUI.Login);
             mWaitingParent.gameObject.SetActive(false);

             #if UNITY_STANDALONE_WIN || UNITY_EDITOR|| SKIP_SDK
             #else
                 SdkConector.ShowToolBar();
             #endif
         }

         //SDK退出
         void SdkLogOff()
         {

             ShowServer(LOGINUI.None);

             mLoginPassInput.value = "";
             mLoginAccountInput.value = "";
         }

         IEnumerator ShakeLabel()
         {
             mPlayEffect = GameMethod.CreateWindow(GameConstDefine.LoadGameLoginEffectPath, new Vector3(-, -, ), mRoot.transform);
             mPlaySubmitBtn.gameObject.SetActive(false);
             yield return new WaitForSeconds(1.4f);
         }

         enum LOGINUI
         {
             None = -,
             Login,
             SelectServer,
         }

         //开始
         Transform mPlayParent;
         Transform mPlaySubmitBtn;
         Transform mPlayServerBtn;
         UILabel mPlayNameLabel;
         UILabel mPlayStateLabel;
         Animator mPlayAnimate;
         GameObject mPlayEffect;

         //登录
         Transform mLoginParent;
         Transform mLoginInput;
         Transform mLoginSubmit;
         UIInput mLoginPassInput;
         UIInput mLoginAccountInput;

         //改变帐号
         Transform mChangeAccountBtn;
         UILabel mChangeAccountName;

         //选服
         Transform mServerParent;

         //重新登录选择
         Transform mReLoginParent;
         Transform mReLoginSubmit;

         //等待中
         Transform mWaitingParent;

         //版本号
         UILabel mVersionLable;

         //服务器列表
         private List<UIToggle> mServerList = new List<UIToggle>();

     }

 }

这里面的EventCenter是什么东西呢？

可以看到类A和类b没有直接交互，而是通过了EventCenter分发事件。比如类b想要执行类A的show（）方法，直接取EventCenter取这个事件委托，然后执行。

那么引入这个中介者模式有什么好处呢，有些人肯定会问不是多此一举吗？本来A和B可以直接交互，偏要引入这个中介者。主要是因为，当两个类或者多个类相互交互，会出现这样的情况。

者也就是违背了类低耦合的远着，类与类之间的依赖过度，我们要减轻这样的练习，引入了中介者。

这样就让一个类只和中介者交互，从一对多变成了一对一，减少了依赖。

---

windowManger.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using BlGame;
using BlGame.GameState;

namespace BlGame.View
{
    /// <summary>
    /// 场景类型枚举，用于场景判断
    /// </summary>
    public enum EScenesType
    {
        EST_None,
        EST_Login,
        EST_Play,
    }

   /// <summary>
   /// 窗口类型，
   /// </summary>
    public enum EWindowType
    {
        EWT_LoginWindow,
        EWT_UserWindow,
        EWT_LobbyWindow,
        EWT_BattleWindow,
        EWT_RoomWindow,
        EWT_HeroWindow,
        EWT_BattleInfoWindow,
        EWT_MarketWindow,
        EWT_MarketHeroListWindow,
        EWT_MarketHeroInfoWindow,
        EWT_MarketRuneListWindow,
        EWT_MarketRuneInfoWindow,
        EWT_SocialWindow,
        EWT_GamePlayWindow,
        EWT_InviteWindow,
        EWT_ChatTaskWindow,
        EWT_ScoreWindow,
        EWT_InviteAddRoomWindow,
        EWT_RoomInviteWindow,
        EWT_TeamMatchWindow,
        EWT_TeamMatchInvitationWindow,
        EWT_TeamMatchSearchingWindow,
        EWT_MailWindow,
        EWT_HomePageWindow,
        EWT_PresonInfoWindow,
        EWT_ServerMatchInvitationWindow,
        EWT_SoleSoldierWindow,
        EWT_MessageWindow,
        EWT_MiniMapWindow,
        EWT_VIPPrerogativeWindow,
        EWT_RuneEquipWindow,
        EWT_DaliyBonusWindow,
        EWT_EquipmentWindow,
        EWT_SystemNoticeWindow,
        EWT_TimeDownWindow,
        EWT_RuneCombineWindow,
        EWT_HeroDatumWindow,
        EWT_RuneRefreshWindow,
        EWT_GamePlayGuideWindow,
        EMT_PurchaseSuccessWindow,
        EMT_GameSettingWindow,
        EMT_AdvancedGuideWindow,
        EMT_ExtraBonusWindow,
        EMT_EnemyWindow,
        EMT_HeroTimeLimitWindow,
        EMT_SkillWindow,
        EMT_SkillDescribleWindow,
        EMT_RuneBuyWindow,
        EMT_DeathWindow,
    }

    /// <summary>
    /// 1、这里windowManger实现了Singleton接口，让自己成为一个单例
    /// 2、这里的Singleton<T> where T : new()
    /// 3、单例这里就不讲了，直接给他人博客：http://www.cnblogs.com/neverdie/p/Learn_Unity3D_Singleton.html
    ///
    /// 总结就是现在WindowManager里面new你的UI子类，然后在Init（）添加show，hide事件监听，然后改变游戏状态，在GameStateManger里面的Enter某个游戏状态
    /// 然后出发show事件，显示UI就是这样
    /// </summary>
    public class WindowManager : Singleton<WindowManager>
    {
        public WindowManager()
        {
            mWidowDic = new Dictionary<EWindowType, BaseWindow>();

            mWidowDic[EWindowType.EWT_LoginWindow] = new LoginWindow();
            mWidowDic[EWindowType.EWT_UserWindow] = new UserInfoWindow();
            mWidowDic[EWindowType.EWT_LobbyWindow] = new LobbyWindow();
            mWidowDic[EWindowType.EWT_BattleWindow] = new BattleWindow();
            mWidowDic[EWindowType.EWT_RoomWindow] = new RoomWindow();
            mWidowDic[EWindowType.EWT_HeroWindow] = new HeroWindow();
            mWidowDic[EWindowType.EWT_BattleInfoWindow] = new BattleInfoWindow();
            mWidowDic[EWindowType.EWT_MarketWindow] = new MarketWindow();
            mWidowDic[EWindowType.EWT_MarketHeroListWindow] = new MarketHeroListWindow();
            mWidowDic[EWindowType.EWT_MarketHeroInfoWindow] = new MarketHeroInfoWindow();
            mWidowDic[EWindowType.EWT_SocialWindow] = new SocialWindow();
            mWidowDic[EWindowType.EWT_GamePlayWindow] = new GamePlayWindow();
            mWidowDic[EWindowType.EWT_InviteWindow] = new InviteWindow();
            mWidowDic[EWindowType.EWT_ChatTaskWindow] = new ChatTaskWindow();
            mWidowDic[EWindowType.EWT_ScoreWindow] = new ScoreWindow();
            mWidowDic[EWindowType.EWT_InviteAddRoomWindow] = new InviteAddRoomWindow();
            mWidowDic[EWindowType.EWT_RoomInviteWindow] = new RoomInviteWindow();
            mWidowDic[EWindowType.EWT_TeamMatchWindow] = new TeamMatchWindow();
            mWidowDic[EWindowType.EWT_TeamMatchInvitationWindow] = new TeamMatchInvitationWindow();
            mWidowDic[EWindowType.EWT_TeamMatchSearchingWindow] = new TeamMatchSearchingWindow();
            mWidowDic[EWindowType.EWT_MailWindow] = new MailWindow();
            mWidowDic[EWindowType.EWT_HomePageWindow] = new HomePageWindow();
            mWidowDic[EWindowType.EWT_PresonInfoWindow] = new PresonInfoWindow();
            mWidowDic[EWindowType.EWT_ServerMatchInvitationWindow] = new ServerMatchInvitationWindow();
            mWidowDic[EWindowType.EWT_SoleSoldierWindow] = new SoleSoldierWindow();
            mWidowDic[EWindowType.EWT_MessageWindow] = new MessageWindow();
            mWidowDic[EWindowType.EWT_MarketRuneListWindow] = new MarketRuneListWindow();
            mWidowDic[EWindowType.EWT_MiniMapWindow] = new MiniMapWindow();
            mWidowDic[EWindowType.EWT_MarketRuneInfoWindow] = new MarketRuneInfoWindow();
            mWidowDic[EWindowType.EWT_VIPPrerogativeWindow] = new VIPPrerogativeWindow();
            mWidowDic[EWindowType.EWT_RuneEquipWindow] = new RuneEquipWindow();
            mWidowDic[EWindowType.EWT_DaliyBonusWindow] = new DaliyBonusWindow();
            mWidowDic[EWindowType.EWT_EquipmentWindow] = new EquipmentWindow();
            mWidowDic[EWindowType.EWT_SystemNoticeWindow] = new SystemNoticeWindow();
            mWidowDic[EWindowType.EWT_TimeDownWindow] = new TimeDownWindow();
            mWidowDic[EWindowType.EWT_RuneCombineWindow] = new RuneCombineWindow();
            mWidowDic[EWindowType.EWT_HeroDatumWindow] = new HeroDatumWindow();
            mWidowDic[EWindowType.EWT_RuneRefreshWindow] = new RuneRefreshWindow();
            mWidowDic[EWindowType.EWT_GamePlayGuideWindow] = new GamePlayGuideWindow();
            mWidowDic[EWindowType.EMT_PurchaseSuccessWindow] = new PurchaseSuccessWindow();
            mWidowDic[EWindowType.EMT_GameSettingWindow] = new GameSettingWindow();
            mWidowDic[EWindowType.EMT_AdvancedGuideWindow] = new AdvancedGuideWindow();
            mWidowDic[EWindowType.EMT_ExtraBonusWindow] = new ExtraBonusWindow();
            mWidowDic[EWindowType.EMT_EnemyWindow] = new EnemyWindow();
            mWidowDic[EWindowType.EMT_HeroTimeLimitWindow] = new HeroTimeLimitWindow();
            mWidowDic[EWindowType.EMT_SkillWindow] = new SkillWindow();
            mWidowDic[EWindowType.EMT_SkillDescribleWindow] = new SkillDescribleWindow();
            mWidowDic[EWindowType.EMT_RuneBuyWindow] = new RuneBuyWindow();
            mWidowDic[EWindowType.EMT_DeathWindow] = new DeathWindow();
        }

        public BaseWindow GetWindow(EWindowType type)
        {
            if (mWidowDic.ContainsKey(type))
                return mWidowDic[type];

            return null;
        }

        public void Update(float deltaTime)
        {
            foreach (BaseWindow pWindow in mWidowDic.Values)
            {
                if (pWindow.IsVisible())
                {
                    pWindow.Update(deltaTime);
                }
            }
        }

        public void ChangeScenseToPlay(EScenesType front)
        {
            foreach (BaseWindow pWindow in mWidowDic.Values)
            {
                if (pWindow.GetScenseType() == EScenesType.EST_Play)
                {
                    pWindow.Init();

                    if(pWindow.IsResident())
                    {
                        pWindow.PreLoad();
                    }
                }
                else if ((pWindow.GetScenseType() == EScenesType.EST_Login) && (front == EScenesType.EST_Login))
                {
                    pWindow.Hide();
                    pWindow.Realse();

                    if (pWindow.IsResident())
                    {
                        pWindow.DelayDestory();
                    }
                }
            }
        }

        public void ChangeScenseToLogin(EScenesType front)
        {
            foreach (BaseWindow pWindow in mWidowDic.Values)
            {
                if (front == EScenesType.EST_None && pWindow.GetScenseType() == EScenesType.EST_None)
                {
                    pWindow.Init();

                    if (pWindow.IsResident())
                    {
                        pWindow.PreLoad();
                    }
                }

                if (pWindow.GetScenseType() == EScenesType.EST_Login)
                {
                    pWindow.Init();

                    if (pWindow.IsResident())
                    {
                        pWindow.PreLoad();
                    }
                }
                else if ((pWindow.GetScenseType() == EScenesType.EST_Play) && (front == EScenesType.EST_Play))
                {
                    pWindow.Hide();
                    pWindow.Realse();

                    if (pWindow.IsResident())
                    {
                        pWindow.DelayDestory();
                    }
                }
            }
        }

        /// <summary>
        /// 隐藏该类型的所有Window
        /// </summary>
        /// <param name="front"></param>
        public void HideAllWindow(EScenesType front)
        {
            foreach (var item in mWidowDic)
            {
                if (front == item.Value.GetScenseType())
                {
                    Debug.Log(item.Key);
                    item.Value.Hide();
                    //item.Value.Realse();
                }
            }
        }

        public void ShowWindowOfType(EWindowType type)
        {
            BaseWindow window;
            if(!mWidowDic.TryGetValue(type , out window))
            {
                return;
            }
            window.Show();
        }

        private Dictionary<EWindowType, BaseWindow> mWidowDic;
    }

}