战斗匹配

点击进入战斗ui界面

控制器

 public class RoomItem
    {
        public UInt64 mRoomId;//房间ID
        public UInt32 mMapId;//地图ID
        public string mOwer;
        public UInt32 mCurNum;//当前人数
        public UInt32 mMaxNum;//最大人数
        public bool mIsPassWord;

        public RoomItem(UInt64 roomId,  UInt32 mapId, string ower, UInt32 curNum, UInt32 maxNum, bool isPassWord)
        {
            mRoomId = roomId;
            mMapId = mapId;
            mOwer = ower;
            mCurNum = curNum;
            mMaxNum = maxNum;
            mIsPassWord = isPassWord;
        }
    }

    public class BattleCtrl : Singleton<BattleCtrl>
    {
        public void Enter()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_BattleEnter);
        }

        public void Exit()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_BattleExit);
        }

        //创建房间
        public void CreateRoom(int mapId, string password)
        {
            CGLCtrl_GameLogin.Instance.CreateRoom(mapId, password);
        }

        //向服务器请求刷新房间列表
        public void AskRoomList()
        {
            CGLCtrl_GameLogin.Instance.AskRoomList();
        }

        //请求加入房间
        public void AskAddRoom(string roomId, string password)
        {
            if (roomId == null || roomId == "" || UInt64.Parse(roomId) <= 0)
            {
                MsgInfoManager.Instance.ShowMsg((int)EErrorCode.eEC_NullBattle);
                EventCenter.Broadcast(EGameEvent.eGameEvent_BattleUpdateRoomList);
                return;
            }

            UInt64 id = UInt64.Parse(roomId);
            if (mRoomList.ContainsKey(id))
            {
                if (mRoomList[id].mIsPassWord && (password == null || password == ""))
                {
                    MsgInfoManager.Instance.ShowMsg((int)EErrorCode.eEC_NULLPassWord);
                    return;
                }
            }

            CGLCtrl_GameLogin.Instance.AddRoom(roomId, password);//讲用户加进来
        }

        //刷新服务器列表
        public void UpdateRoomList(List<GSToGC.RoomInfo> roomList)
        {
            mRoomList.Clear();

            foreach (GSToGC.RoomInfo roomInfo in roomList)
            {
                AddRoomItem((UInt32)roomInfo.roomId, (UInt32)roomInfo.mapId, roomInfo.master, (UInt32)roomInfo.curUserCount,(UInt32)roomInfo.maxUserCount, (roomInfo.ifPwd == 1));
            }

            EventCenter.Broadcast(EGameEvent.eGameEvent_BattleUpdateRoomList);
        }

        //更新房间列表
        private void AddRoomItem(UInt64 roomId,UInt32 mapId,string ower,UInt32 curNum,UInt32 maxNum,bool isPassword)
        {
            RoomItem room = new RoomItem(roomId,mapId,ower,curNum,maxNum, isPassword);
            
            mRoomList.Add(roomId,room);
        }

        //取得房间列表
        public Dictionary<UInt64, RoomItem> GetRoomList()
        {
            return mRoomList;
        }

        //取得房间信息
        public RoomItem GetRoomInfo(UInt32 id)
        {
            if (mRoomList.ContainsKey(id))
            {
                return mRoomList[id];
            }

            return null;
        }

        //申请组队匹配
        public void AskMatchBattle(int mapId, EBattleMatchType mt)
        {
            mMapId = mapId;//地图ID
            mMatchType = mt;//比赛的类型

            CGLCtrl_GameLogin.Instance.AskMatchBattle(mapId, mt); //请求战斗匹配
        }

        //申请创建新手战役
        public void AskCreateGuideBattle(int mapId, AskCSCreateGuideBattle.guidetype mGtype)
        {
            mMapId = mapId;

            UIGuideCtrl.Instance.GuideBattleType(mGtype);

            CGLCtrl_GameLogin.Instance.AskCSToCreateGuideBattle(mapId, mGtype);
        }

        public int GetMapId()
        {
            return mMapId;
        }

        public EBattleMatchType GetMatchType()
        {
            return mMatchType;
        }

        Dictionary<UInt64, RoomItem> mRoomList = new Dictionary<UInt64, RoomItem>();

        private int mMapId = 0;
        private EBattleMatchType mMatchType = EBattleMatchType.EBMT_Normal;
    }

界面

 //大厅战斗主界面，包括创建房间，加入房间， 匹配选择等
    public class BattleWindow : BaseWindow
    {
        public BattleWindow()
        {
            mScenesType = EScenesType.EST_Login;
            mResName = GameConstDefine.LoadGameBattleUI;
            mResident = true;
        }

        ////////////////////////////继承接口/////////////////////////
        //类对象初始化
        public override void Init()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_BattleEnter, Show);
            EventCenter.AddListener(EGameEvent.eGameEvent_BattleExit, Hide);
            EventCenter.AddListener(EGameEvent.eGameEvent_LobbyExit, Hide);
        }

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

        //窗口控件初始化
        protected override void InitWidget()
        {
            //创建房间
            mCustomToggle = mRoot.FindChild("ModeSelect/Custom").GetComponent<UIToggle>();
            mCustomMapGrid = mRoot.FindChild("CustomInterface/CreateBattles/Mapselect/Grid");
            mRoomPassword = mRoot.FindChild("CustomInterface/CreateBattles/Password").GetComponent<UIInput>();
            mCreateRoom = mRoot.FindChild("CustomInterface/CreateBattles/CreateButton").gameObject;

            GameObject tranning = mRoot.FindChild("ModeSelect/Training").gameObject;
            mTranningToggle = tranning.GetComponent<UIToggle>();
            UIGuideCtrl.Instance.AddUiGuideEventBtn(tranning);

            EventDelegate.Add(mCustomToggle.onChange, OnCustom);//自定义
            EventDelegate.Add(mTranningToggle.onChange, OnTranning);//训练
            UIEventListener.Get(mCreateRoom).onClick += OnCreateRoom;//创建房间
            
            //加入房间
            mAddRoomTG = mRoot.FindChild("CustomInterface/JoinBtn").GetComponent<UIToggle>();
            mRoomListGrid = mRoot.FindChild("CustomInterface/JoinBattles/RoomList/Grid");
            mJoinBt = mRoot.FindChild("CustomInterface/JoinBattles/Button/Join").GetComponent<UIButton>();
            mRefreshBt = mRoot.FindChild("CustomInterface/JoinBattles/Button/Refresh").GetComponent<UIButton>();
            mSearchBt = mRoot.FindChild("CustomInterface/JoinBattles/Button/Search").GetComponent<UIButton>();

            mPasswordPanel = mRoot.FindChild("CustomInterface/JoinBattles/PasswordInput");
            mPasswordInput = mRoot.FindChild("CustomInterface/JoinBattles/PasswordInput/Password").GetComponent<UIInput>();
            mAddJoin = mRoot.FindChild("CustomInterface/JoinBattles/PasswordInput/Join").GetComponent<UIButton>();
            mAddBack = mRoot.FindChild("CustomInterface/JoinBattles/PasswordInput/Back").GetComponent<UIButton>();
            

            EventDelegate.Add(mAddRoomTG.onChange, OnShowAddRoomPanel);
            EventDelegate.Add(mJoinBt.onClick, OnJoin);
            EventDelegate.Add(mRefreshBt.onClick, OnRefresh);
            EventDelegate.Add(mSearchBt.onClick, OnSearch);

            EventDelegate.Add(mAddJoin.onClick, OnAddJoinRoom);
            EventDelegate.Add(mAddBack.onClick, OnAddBack);

            //查找房间
            mSearchInterface = mRoot.FindChild("CustomInterface/JoinBattles/SearchInterface");
            mSearchRoomIDInput = mRoot.FindChild("CustomInterface/JoinBattles/SearchInterface/RoomID").GetComponent<UIInput>();
            mSearchPassWordInput = mRoot.FindChild("CustomInterface/JoinBattles/SearchInterface/Password").GetComponent<UIInput>();
            mSearchAddBt = mRoot.FindChild("CustomInterface/JoinBattles/SearchInterface/Join").GetComponent<UIButton>();
            mSearchBackBt = mRoot.FindChild("CustomInterface/JoinBattles/SearchInterface/Back").GetComponent<UIButton>(); ;

            EventDelegate.Add(mSearchAddBt.onClick, OnSearchJoinRoom);
            EventDelegate.Add(mSearchBackBt.onClick, OnSearchBack);

            //匹配
            mMatchToggle = mRoot.FindChild("ModeSelect/Match").GetComponent<UIToggle>();
            mMatChNormal = mRoot.FindChild("MatchInterface/BattleMode/Normal").GetComponent<UIToggle>();
            mMatChAi = mRoot.FindChild("MatchInterface/BattleMode/AI").GetComponent<UIToggle>();
            mMatchRank = mRoot.FindChild("MatchInterface/BattleMode/RankUp").GetComponent<UIToggle>();
            mMatchMapGrid = mRoot.FindChild("MatchInterface/MapSelect/Grid");

            //新手引导
            mMap1 = mRoot.FindChild("TrainingInterface/MapSelect/Grid/1001").gameObject;
            mMap2 = mRoot.FindChild("TrainingInterface/MapSelect/Grid/1002").gameObject;
            UIGuideCtrl.Instance.AddUiGuideEventBtn(mMap1);
            //UIGuideCtrl.Instance.AddUiGuideEventBtn(mMap2);

            EventDelegate.Add(mMatChNormal.onChange, OnMatchModelChange);
            EventDelegate.Add(mMatChAi.onChange, OnMatchModelChange);
            EventDelegate.Add(mMatchRank.onChange, OnMatchModelChange);

            mRoomID = 0;
            mMatchType = EBattleMatchType.EBMT_Normal;
            mJoinBt.isEnabled = false;
        }

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

        }

     
        //游戏事件注册
        protected override void OnAddListener()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_BattleUpdateRoomList, UpdateRoomList);
            EventCenter.AddListener<EErrorCode>(EGameEvent.eGameEvent_AskFriendEorr, EventError);
            EventCenter.AddListener<EErrorCode>(EGameEvent.eGameEvent_AskAddInBattle, EventError);
        }

        //游戏事件注消
        protected override void OnRemoveListener()
        {
            EventCenter.RemoveListener(EGameEvent.eGameEvent_BattleUpdateRoomList, UpdateRoomList);
            EventCenter.RemoveListener<EErrorCode>(EGameEvent.eGameEvent_AskFriendEorr, EventError);
            EventCenter.AddListener<EErrorCode>(EGameEvent.eGameEvent_AskAddInBattle, EventError);
            
        }

        //显示
        public override void OnEnable()
        {
        }

        //隐藏
        public override void OnDisable()
        {
            //因为常驻，关闭时重置选项
            mMapId = 0;
            OnCustomMapRefresh();
            mSearchInterface.gameObject.SetActive(false);
            mPasswordPanel.gameObject.SetActive(false);
        }

        private void EventError(EErrorCode arg1)
        {
            MsgInfoManager.Instance.ShowMsg((int)arg1);
        }

        //新手训练
        public void OnTranning()
        {
            if (mTranningToggle.value)
            {
                OnTranningMapRefresh();
            }
        }  

        public void OnCustom()
        {
            if(mCustomToggle.value)
            {
                OnCustomMapRefresh();
            }
        }   

        public void OnTranningMapRefresh()
        {
            UIEventListener.Get(mMap1).onClick += OnGuideSelectMap;//选择地图
            UIEventListener.Get(mMap2).onClick += OnGuideSelectMap;
        }

        //刷新自定义地图列表
        public void OnCustomMapRefresh()
        {
            if (mCustomToggle.value)
            {
                LoadUiResource.ClearAllChild(mCustomMapGrid);

                List<MapInfo> mapList = MapLoadConfig.Instance.GetMapList(EBattleMatchType.EBMT_None);

                for (int i = 0; i < mapList.Count; i++)
                {
                    if (mapList[i].mIsTrain == false)
                    {
                        AddCustomMapItem(mapList[i]);
                    }
                }

                mMapId = 0;
                mRoomPassword.value = "";
            }

            mCustomMapGrid.GetComponent<UIGrid>().Reposition();
        }

        //增加自定义地图选项
        private void AddCustomMapItem(MapInfo info)
        {
            GameObject obj = LoadUiResource.AddChildObject(mCustomMapGrid, GameConstDefine.LoadGameLobbyCustomMapItem);
            if (obj != null)
            {
                obj.name = info.mId.ToString();
                obj.transform.FindChild("tSprite").GetComponent<UISprite>().spriteName = info.mShowPic;
                UIEventListener.Get(obj).onClick += OnCustomSelectMap;
            }
        }

        //自定义选择地图
        private void OnCustomSelectMap(GameObject obj)
        {
            mMapId = Convert.ToInt32(obj.name);
        }

        //新建房间
        public void OnCreateRoom(GameObject go)
        {
            if (mMapId <= 0)
            {
                MsgInfoManager.Instance.ShowMsg(40051);
                return;
            }
            BattleCtrl.Instance.CreateRoom(mMapId, mRoomPassword.value);
        }

        //显示房间列表
        public void OnShowAddRoomPanel()
        {
            mRoomPassword.value = "";
            OnRefresh();
        }

        //打开加入面板
        public void OnJoin()
        {
            if (mCurRoomItem == null || mRoomID == 0)
            {
                return;
            }

            RoomItem room = BattleCtrl.Instance.GetRoomInfo(mRoomID);
            if (room!=null && !room.mIsPassWord)
            {
                BattleCtrl.Instance.AskAddRoom(mRoomID.ToString(), "0");
            }
            else
            {
                mPasswordPanel.gameObject.SetActive(true);
                mPasswordInput.value = "";
            }
         }

        //刷新房间列表
        public void OnRefresh()
        {
             BattleCtrl.Instance.AskRoomList();
        }

        //加入房间
        public void OnAddJoinRoom()
        {
            BattleCtrl.Instance.AskAddRoom(mRoomID.ToString(), mPasswordInput.text);
        }

        //加入房间返回
        public void OnAddBack()
        {
            mPasswordPanel.gameObject.SetActive(false);
        }

        //更新房间列表
        private void UpdateRoomList()
        {
            //清空原来的列表
            LoadUiResource.ClearAllChild(mRoomListGrid);

            mCurRoomItem = null;
            mRoomID = 0;
            mJoinBt.isEnabled = false;

            //加入新的列表
            Dictionary<UInt64, RoomItem> RoomList = BattleCtrl.Instance.GetRoomList();
            foreach (RoomItem roomInfo in RoomList.Values)
            {
                AddRoomItem(roomInfo);
            }

            //默认选择第一个
            if (mRoomListGrid.childCount > 0)
            {
                mRoomListGrid.GetChild(0).GetComponent<UIToggle>().value = true;
            }

            mRoomListGrid.GetComponent<UIGrid>().Reposition();
        }

        //加入一个房间项
        private void AddRoomItem(RoomItem roomInfo)
        {
            GameObject gameObj = LoadUiResource.AddChildObject(mRoomListGrid, GameConstDefine.LoadGameLobbyRoomItemUI);

            if (gameObj == null)
                return;

            Transform obj = gameObj.transform;

            if (obj != null)
            {
                mRoomIDLabel = obj.FindChild("RoomID").GetComponent<UILabel>();
                mRoomIDLabel.text = roomInfo.mRoomId.ToString();

                mMapName = obj.FindChild("MapName").GetComponent<UILabel>();
                MapInfo mapInfo = MapLoadConfig.Instance.GetMapInfo(roomInfo.mMapId);
                if (mapInfo == null)
                {
                    Debug.LogError("mapLoadConfig Not find");
                    return;
                }
                mMapName.text = mapInfo.mName;

                mCreator = obj.FindChild("Creator").GetComponent<UILabel>();
                mCreator.text = roomInfo.mOwer;

                mStatus = obj.FindChild("Status").GetComponent<UILabel>();
                mStatus.text = roomInfo.mCurNum.ToString() + "/" + roomInfo.mMaxNum.ToString();
                
                mLock =   obj.FindChild("Lock").gameObject;
                mLock.SetActive(roomInfo.mIsPassWord);

                mHighlight = obj.FindChild("Highlight").gameObject;
                mHighlight.SetActive(false);
            }

            UIToggle item = obj.GetComponent<UIToggle>();
            EventDelegate.Add(item.onChange, OnRoomItemToggle);
        }

        //选择房间
        public void OnRoomItemToggle()
        {
            if (UIToggle.current != null && UIToggle.current.value)
            {
                if (mCurRoomItem != null)
                {
                    mHighlight = mCurRoomItem.FindChild("Highlight").gameObject;
                    mHighlight.SetActive(false);
                }

                mCurRoomItem = UIToggle.current.transform;

                mHighlight = mCurRoomItem.FindChild("Highlight").gameObject;
                mHighlight.SetActive(true);

                mRoomIDLabel = mCurRoomItem.FindChild("RoomID").GetComponent<UILabel>();
                mRoomID = UInt32.Parse(mRoomIDLabel.text);

                mJoinBt.isEnabled = true;
            }
        }

        //打开查找界面
        public void OnSearch()
        {
            mSearchInterface.gameObject.SetActive(true);
            mSearchRoomIDInput.value = "";
            mSearchPassWordInput.value = "";
        }

        //加入房间（通过查找)
        public void OnSearchJoinRoom()
        {
            BattleCtrl.Instance.AskAddRoom(mSearchRoomIDInput.text,mSearchPassWordInput.text);
        }

        //查找返回
        public void OnSearchBack()
        {
             mSearchInterface.gameObject.SetActive(false);
        }

        //匹配模式切换
        public void OnMatchModelChange()
        {
            if (UIToggle.current != null && UIToggle.current.isChecked)
            {
                LoadUiResource.ClearAllChild(mMatchMapGrid);

                List<MapInfo> mapList = new List<MapInfo>();
                if (UIToggle.current == mMatChNormal)
                {
                    mapList = MapLoadConfig.Instance.GetMapList(EBattleMatchType.EBMT_Normal);//加载当前的地图
                    mMatchType = EBattleMatchType.EBMT_Normal;
                }
                else if (UIToggle.current == mMatChAi)
                {
                    mapList = MapLoadConfig.Instance.GetMapList(EBattleMatchType.EBMT_Ai);
                    mMatchType = EBattleMatchType.EBMT_Ai;
                }
                else if (UIToggle.current == mMatchRank)
                {
                    mapList = MapLoadConfig.Instance.GetMapList(EBattleMatchType.EBMT_Rank);
                    mMatchType = EBattleMatchType.EBMT_Rank;
                }

                for (int i = 0; i < mapList.Count; i++)
                {
                    AddMatchMapItem(mapList[i]);//增加匹配地图项
                }
            }

            mMatchMapGrid.GetComponent<UIGrid>().Reposition();
        }

        //增加匹配地图选项
        private void AddMatchMapItem(MapInfo info)
        {
            GameObject obj = LoadUiResource.AddChildObject(mMatchMapGrid, GameConstDefine.LoadGameLobbyMatchMapItem);
            if (obj != null)
            {
                obj.name = info.mId.ToString(); 
                obj.transform.FindChild("tSprite").GetComponent<UISprite>().spriteName = info.mShowPic;
                UIEventListener.Get(obj).onClick += OnMatchSelectMap;//选择地图
             }
        }

        //新手训练选择地图
        private void OnGuideSelectMap(GameObject obj)
        {
            if (obj == mMap1)
            {
                BattleCtrl.Instance.AskCreateGuideBattle(1000, GCToCS.AskCSCreateGuideBattle.guidetype.first);
            }
            else
            {
                GameLogic.Instance.IsQuickBattle = true;
                BattleCtrl.Instance.AskCreateGuideBattle(1001, GCToCS.AskCSCreateGuideBattle.guidetype.second);
            }
            
        }

        //匹配选择地图
        private void OnMatchSelectMap(GameObject obj)
        {
            BattleCtrl.Instance.AskMatchBattle(Convert.ToInt32(obj.name), mMatchType);
        }
        
        //创建房间
        Transform mCustomMapGrid;    //地图列表
        UIToggle mMatchToggle;
        UIToggle mCustomToggle;
        UIToggle mTranningToggle;
        UIInput mRoomPassword;
        GameObject mCreateRoom;
        Int32 mMapId;

        //加入房间
        UIToggle mAddRoomTG;
        Transform mRoomListGrid;
        Transform mCurRoomItem;

        UILabel mRoomIDLabel;
        UILabel mMapName;
        UILabel mCreator;
        UILabel mStatus;
        GameObject mLock;
        GameObject mHighlight;

        UIButton mJoinBt;
        UIButton mRefreshBt;
        UIButton mSearchBt;

        Transform mPasswordPanel;
        UIInput mPasswordInput;
        UIButton mAddJoin;
        UIButton mAddBack;

        //查找
        Transform mSearchInterface;
        UIInput mSearchRoomIDInput;
        UIInput mSearchPassWordInput;
        UIButton mSearchAddBt;
        UIButton mSearchBackBt;

        //匹配
        UIToggle mMatChNormal;   //普通
        UIToggle mMatChAi;       //人机
        UIToggle mMatchRank;     //天梯
        Transform mMatchMapGrid;    //地图列表

        //新手引导
        GameObject mMap1;
        GameObject mMap2;

        //数据
        UInt32 mRoomID;    //房间ID
        EBattleMatchType mMatchType;  // 匹配模式

}

匹配的控制类，包含好几个窗体的控制 

 public class Teammate
    {
        public uint mPostion;
        public string mName;
        public string mPic;
        public uint mLv;

        public Teammate(uint pos, string name, string pic, uint lv)
        {
            mPostion = pos;
            mName = name;
            mPic = pic;
            mLv = lv;
        }
    }

    public class TeamMatchCtrl : Singleton<TeamMatchCtrl>
    {

        public void Enter()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_TeamMatchEnter);
        }

        public void Exit()
        {
            mTeammateList.Clear();

            EventCenter.Broadcast(EGameEvent.eGameEvent_TeamMatchExit);
        }

        //邀请好友组队匹配
        public void InvitationFriend(string nickName)
        {
            CGLCtrl_GameLogin.Instance.AskInvitationFriend(nickName);
        }

        //新增队友
        public void AddTeammate(uint pos,string name, string pic, uint lv)
        {
            Teammate teammate = new Teammate(pos,name, pic, lv);
            mTeammateList.Add(name, teammate);

            EventCenter.Broadcast<Teammate>(EGameEvent.eGameEvent_TeamMatchAddTeammate, teammate);
        }

        //删除队友
        public void DelTeammate(string nickName)
        {
            mTeammateList.Remove(nickName);

            EventCenter.Broadcast<string>(EGameEvent.eGameEvent_TeamMatchDelTeammate, nickName);
        }

        //请求开始匹配
        public void AskStartMatch()
        {
            CGLCtrl_GameLogin.Instance.AskStartTeamMatch();
        }

        //请求停止匹配
        public void AskStopMatch()
        {
            CGLCtrl_GameLogin.Instance.AskStopTeamMatch();
        }

        //开始匹配
        public void StartMatchSearching()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_TeamMatchSearchinEnter);
        }

        //停止匹配
        public void StopMatchSearching()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_TeamMatchSearchinExit);
        }

        //取得队友列表
        public Dictionary<string,Teammate> GetTeammateList()
        {
            return mTeammateList;
        }

        //打开组队匹配
        public void InitTeamBaseInfo(uint mapId, uint matchType)
        {
            mMapId = mapId;
            mMatchType = (EBattleMatchType)matchType;

            mTeammateList.Clear();
        }

        //打开组队邀请
        public void ShowInvitation(string name)
        {
            EventCenter.Broadcast<string>(EGameEvent.eGameEvent_TeamMatchInvitationEnter, name);
        }

       

        //隐藏组队邀请
        public void HideInvitation()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_TeamMatchInvitationExit);
        }

        //接受组队邀请
        public void AccpetInvitation(string name)
        {
            CGLCtrl_GameLogin.Instance.AskAcceptInvitation(name);
        }

        //打开服务器邀请
        public void ShowServerInvitation(uint mapid, uint fightid)
        {
            EventCenter.Broadcast<uint, uint>(EGameEvent.eGameEvent_ServerMatchInvitationEnter, mapid, fightid);
        }

        //反馈服务器邀请
        public void ResponseServerInvitation(uint mapid, uint fightid, bool accpet)
        {
            CGLCtrl_GameLogin.Instance.AskResponseServerInvitation(mapid, fightid, accpet);
        }      

        //退出队伍
        public void QuitTeam()
        {
            CGLCtrl_GameLogin.Instance.AskQuitTeam();
        }

        public bool IsTeamFull()
        {
            MapInfo info = MapLoadConfig.Instance.GetMapInfo(mMapId);

            if (info != null && mTeammateList.Count >= (info.mPlayerNum / 2))
            {
                return true;
            }

            return false;
        }

        Dictionary<string, Teammate> mTeammateList = new Dictionary<string,Teammate>();

        public uint GetMapId()
        {
            return mMapId;
        }

        public EBattleMatchType GetMatchType()
        {
            return mMatchType;
        }

        private uint mMapId = 0;
        private EBattleMatchType mMatchType = EBattleMatchType.EBMT_Normal;
    }

 窗体

 public class TeamMatchWindow : BaseWindow
    {
        public TeamMatchWindow()
        {
            mScenesType = EScenesType.EST_Login;
            mResName = GameConstDefine.LoadGameTeamMatchUI;
            mResident = false;
        }

        ////////////////////////////继承接口/////////////////////////
        //类对象初始化
        public override void Init()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_TeamMatchEnter, Show);
            EventCenter.AddListener(EGameEvent.eGameEvent_TeamMatchExit, Hide);
            EventCenter.AddListener(EGameEvent.eGameEvent_LobbyExit, Hide);
        }

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

        //窗口控件初始化
        protected override void InitWidget()
        {
            //地图
            mMapNameLabel = mRoot.FindChild("MapInfo/Name").GetComponent<UILabel>();
            mMapTypeLabel = mRoot.FindChild("MapInfo/Type").GetComponent<UILabel>();
            mQuitBtn = mRoot.FindChild("QuitBtn").GetComponent<UIButton>();
            mMatchBtn = mRoot.FindChild("MatchBtn").GetComponent<UIButton>();

            //好友
            mFriendList = mRoot.FindChild("InvitationList/Grid");
            mInvitation = mRoot.FindChild("InvitationBtn").GetComponent<UIButton>();

            //队友
            mTeammateList = mRoot.FindChild("TeamMember");

            EventDelegate.Add(mQuitBtn.onClick, OnQuit);
            EventDelegate.Add(mInvitation.onClick, OnInvitation);//邀请
            EventDelegate.Add(mMatchBtn.onClick, OnMatch);//匹配
        }

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

        }

     
        //游戏事件注册
        protected override void OnAddListener()
        {
            EventCenter.AddListener<Teammate>(EGameEvent.eGameEvent_TeamMatchAddTeammate, AddTeammate);
            EventCenter.AddListener<string>(EGameEvent.eGameEvent_TeamMatchDelTeammate, DelTeammate);

            EventCenter.AddListener<Friend>(EGameEvent.eGameEvent_CreateFriendPrefab, AddFriend);
            EventCenter.AddListener<UInt64>(EGameEvent.eGameEvent_RemoveFriend, DelFriend);
            EventCenter.AddListener<UInt64>(EGameEvent.eGameEvent_FriendChangeInfo, ChangeOnLine);
        }

        //游戏事件注消
        protected override void OnRemoveListener()
        {
            EventCenter.RemoveListener<Teammate>(EGameEvent.eGameEvent_TeamMatchAddTeammate, AddTeammate);
            EventCenter.RemoveListener<string>(EGameEvent.eGameEvent_TeamMatchDelTeammate, DelTeammate);

            EventCenter.RemoveListener<Friend>(EGameEvent.eGameEvent_CreateFriendPrefab, AddFriend);
            EventCenter.RemoveListener<UInt64>(EGameEvent.eGameEvent_RemoveFriend, DelFriend);
            EventCenter.RemoveListener<UInt64>(EGameEvent.eGameEvent_FriendChangeInfo, ChangeOnLine);
            
        }

        //显示
        public override void OnEnable()
        {
            //地图信息填充
            MapInfo info = MapLoadConfig.Instance.GetMapInfo(TeamMatchCtrl.Instance.GetMapId());

            if (info != null)
            {
                mMapNameLabel.text = info.mName;
                switch (TeamMatchCtrl.Instance.GetMatchType())
                {
                    case EBattleMatchType.EBMT_Normal:
                         mMapTypeLabel.text = "(" + ConfigReader.GetMsgInfo(40038).content + ")";
                         break;
                    case EBattleMatchType.EBMT_Rank:
                         mMapTypeLabel.text = "(" + ConfigReader.GetMsgInfo(40040).content + ")";
                        break;
                    case EBattleMatchType.EBMT_Ai:
                        mMapTypeLabel.text = "(" + ConfigReader.GetMsgInfo(40039).content + ")";
                        break;

                }
            }

            //更新好友列表
            RefreshFrienList();

            //清空队友
            LoadUiResource.ClearAllChild(mTeammateList);
        }

        //隐藏
        public override void OnDisable()
        {

        }

        //玩家好友列表更新
        private void RefreshFrienList(string name = "")
        {
            LoadUiResource.ClearAllChild(mFriendList);

            foreach (Friend friend in FriendManager.Instance.AllFriends.Values)
            {
                if (TeamMatchCtrl.Instance.GetTeammateList().ContainsKey(friend.NiceName) || (friend.isOnline == false))
                    continue;

                AddFriendItem(friend);
            }

            mFriendList.GetComponent<UIGrid>().Reposition();

            mInvitation.isEnabled = false;
        }

         //增加一个好友
        private void AddFriend(Friend friend)
        {
            if (friend.isOnline == true)
            {
                AddFriendItem(friend);
                mFriendList.GetComponent<UIGrid>().Reposition();
            }
        }

        
        //更新好友属性改变(在线否)
        private void ChangeOnLine(UInt64 temp)
        {
            if (FriendManager.Instance.AllFriends.ContainsKey(temp))
            {
                Friend friend = FriendManager.Instance.AllFriends[temp];
                if (friend.isOnline == false)
                {
                    LoadUiResource.ClearOneChild(mFriendList,friend.NiceName);
                    mFriendList.GetComponent<UIGrid>().Reposition();

                    OnFriendSelect(null);
                }
                else
                {
                    AddFriend(friend);
                }
            }
        }

        //删除一个好友
        private void DelFriend(UInt64 temp)
        {
            if (FriendManager.Instance.AllFriends.ContainsKey(temp))
            {
                LoadUiResource.ClearOneChild(mFriendList, FriendManager.Instance.AllFriends[temp].NiceName);

                mFriendList.GetComponent<UIGrid>().Reposition();

                OnFriendSelect(null);
            }
        }

        //增加一个好友选项
        private void AddFriendItem(Friend info)
        {
            GameObject obj = LoadUiResource.AddChildObject(mFriendList, GameConstDefine.LoadGameMatchFriendsItem);
            if (obj != null)
            {
                obj.name = info.NiceName;
                obj.transform.FindChild("Name").GetComponent<UILabel>().text = info.NiceName;
                UIEventListener.Get(obj).onClick += OnFriendSelect;
            }
        }

        private void OnFriendSelect(GameObject obj)
        {
            if (mIsLeader)
            {
                int count = 0;
                for (int i = 0; i < mFriendList.childCount; i++)
                {
                    if (mFriendList.GetChild(i).GetComponent<UIToggle>().value)
                    {
                        ++count;
                    }
                }

                if (count > 0 && !TeamMatchCtrl.Instance.IsTeamFull())
                {
                    mInvitation.isEnabled = true;
                }
                else
                {
                    mInvitation.isEnabled = false;
                }
            }
        }

        //邀请
        private void OnInvitation()
        {
            int count = 0;
            for (int i = 0; i < mFriendList.childCount; i++)
            {
                if (mFriendList.GetChild(i).GetComponent<UIToggle>().isChecked)
                {
                    TeamMatchCtrl.Instance.InvitationFriend(mFriendList.GetChild(i).gameObject.name);
                    ++count;
                }
            }

            if (count > 0)
            {
                MsgInfoManager.Instance.ShowMsg(-130775);
            }
            else
            {
                MsgInfoManager.Instance.ShowMsg(40049);
            }
            
        }

        //匹配
        private void OnMatch()
        {
            TeamMatchCtrl.Instance.AskStartMatch();
        }

        //更新队友列表
        private void RefreshTeammateList()
        {
            //更新功能按钮状态
            if (GameUserModel.Instance.GameUserNick == mMasterName)
            {
                mIsLeader = true;
                mMatchBtn.isEnabled = true;
            }
            else
            {
                mIsLeader = false;
                mMatchBtn.isEnabled = false;
            }

            mTeammateList.GetComponent<UIGrid>().Reposition();
        }

        //新增一个队友
        private void AddTeammate(Teammate team)
        {
            GameObject obj = LoadUiResource.AddChildObject(mTeammateList, GameConstDefine.LoadGameMatchTeammateItem);
            if (obj != null)
            {
                obj.name = team.mName;
                obj.transform.FindChild("Name").GetComponent<UILabel>().text = team.mName;
                obj.transform.FindChild("Head").GetComponent<UISprite>().spriteName = team.mPic;
                obj.transform.FindChild("Level").GetComponent<UILabel>().text = "LV" + team.mLv;

                //找出队长名称
                if (team.mPostion == 0)
                {
                    mMasterName = team.mName;
                }

                //删除好友
                foreach (Friend friend in FriendManager.Instance.AllFriends.Values)
                {
                    if (friend.NiceName == team.mName)
                    {
                        DelFriend(friend.SGUID);
                    }
                }

                RefreshTeammateList();
            }
        }

        //删除一个队友
        private void DelTeammate(string name)
        {
            LoadUiResource.ClearOneChild(mTeammateList,name);

            //增加好友
            foreach (Friend friend in FriendManager.Instance.AllFriends.Values)
            {
                if (friend.NiceName == name && friend.isOnline == true)
                {
                    AddFriend(friend);
                }
            }

            RefreshTeammateList();

            OnFriendSelect(null);
        }


        //退出
        public void OnQuit()
        {
            TeamMatchCtrl.Instance.QuitTeam();
        }

        UILabel mMapNameLabel;
        UILabel mMapTypeLabel;

        Transform mFriendList;
        Transform mTeammateList;
        UIButton mInvitation;
        UIButton mMatchBtn;
        UIButton mQuitBtn;

        string mMasterName;
       string mCurFriend;
       bool mIsLeader;
    }

 public class TeamMatchSearchingWindow : BaseWindow
    {
        public TeamMatchSearchingWindow()
        {
            mScenesType = EScenesType.EST_Login;
            mResName = GameConstDefine.LoadGameMatchSearchingUI;
            mResident = false;
        }

        ////////////////////////////继承接口/////////////////////////
        //类对象初始化
        public override void Init()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_TeamMatchSearchinEnter, Show);
            EventCenter.AddListener(EGameEvent.eGameEvent_TeamMatchSearchinExit, Hide);
            EventCenter.AddListener(EGameEvent.eGameEvent_LobbyExit, Hide);
        }

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

        //窗口控件初始化
        protected override void InitWidget()
        {
            mTimeLabel = mRoot.FindChild("Time").GetComponent<UILabel>();
            mNumberLabel = mRoot.FindChild("MatchedNum").GetComponent<UILabel>();
            mCancel = mRoot.FindChild("CancelBtn").GetComponent<UIButton>();

            EventDelegate.Add(mCancel.onClick, OnCancel);
        }

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

        }

     
        //游戏事件注册
        protected override void OnAddListener()
        {
            EventCenter.AddListener<int,int>(EGameEvent.eGameEvent_MatchNumber, ChangeMatchNumber);
        }

        //游戏事件注消
        protected override void OnRemoveListener()
        {
            EventCenter.RemoveListener<int,int>(EGameEvent.eGameEvent_MatchNumber, ChangeMatchNumber);
        }

        //显示
        public override void OnEnable()
        {
            mIsDownTime = true;
        }

        //隐藏
        public override void OnDisable()
        {
            mIsDownTime = false;
            mStartTime = 0;
        }

        //时间的更新
        public override void Update(float deltaTime)
        {
            if (mIsDownTime)
            {
                mStartTime += Time.deltaTime;
                ShowCount(mTimeLabel, (int)mStartTime);
            }
        }

        //显示时间
        private void ShowCount(UILabel label, int time)
        {
            string timeString = "";
            if (time < 60)
                timeString = "00:" + SecondToStr(time);
            else
                timeString = SecondToStr(time / 60) + ":" + SecondToStr(time % 60);

            label.text = timeString;
        }

        private string SecondToStr(int time)
        {
            string timeString = "";
            if (time < 10)
                timeString = "0" + time.ToString();
            else
                timeString = "" + time.ToString();

            return timeString;
        }

        public void OnCancel()
        {
            TeamMatchCtrl.Instance.AskStopMatch();//取消的时候告诉服务器

            Hide();
        }

        public void ChangeMatchNumber(int cur,int max)
        {
            mNumberLabel.text = cur.ToString() + "/" + max.ToString();
        }

        UILabel mTimeLabel;
        UILabel mNumberLabel;
        UIButton mCancel;

        private float mStartTime = 0;
        private bool mIsDownTime = false;
    }

 

  class HeroState : IGameState
    {
        GameStateType stateTo;

        GameObject mScenesRoot;

        GameObject mUIRoot;

        public HeroState()
        {
        }

        public GameStateType GetStateType()
        {
            return GameStateType.GS_Hero;
        }

        public void SetStateTo(GameStateType gs)
        {
            stateTo = gs;
        }

        //界面初始化出来
        public void Enter()
        {
            SetStateTo(GameStateType.GS_Continue);
           

            HeroCtrl.Instance.Enter();

            ResourceUnit clipUnit = ResourcesManager.Instance.loadImmediate(AudioDefine.PATH_UIBGSOUND, ResourceType.ASSET);
          
            AudioClip clip = clipUnit.Asset as AudioClip;
            AudioManager.Instance.PlayBgAudio(clip);
                                                
            EventCenter.AddListener<CEvent>(EGameEvent.eGameEvent_Loading, OnEvent);
            EventCenter.AddListener(EGameEvent.eGameEvent_ConnectServerFail, OnConnectServerFail);
            EventCenter.AddListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff); 
        }

        public void Exit()
        {
            EventCenter.RemoveListener<CEvent>(EGameEvent.eGameEvent_Loading, OnEvent);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_ConnectServerFail, OnConnectServerFail);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_SdkLogOff, SdkLogOff); 

            HeroCtrl.Instance.Exit();
        }

        public void OnConnectServerFail()
        {
            EventCenter.Broadcast<EMessageType>(EGameEvent.eGameEvent_ShowMessage, EMessageType.EMT_Reconnect);
        }

        public void FixedUpdate(float fixedDeltaTime)
        {

        }

        public GameStateType Update(float fDeltaTime)
        {
            return stateTo;
        }

        public void OnEvent(CEvent evt)
        {
            switch (evt.GetEventId())
            {
                case EGameEvent.eGameEvent_Loading:
                    {
                        GameStateType stateType = (GameStateType)evt.GetParam("NextState");
                        LoadingState lState = GameStateManager.Instance.getState(GameStateType.GS_Loading) as LoadingState;
                        lState.SetNextState(stateType);
                        lState.SetFrontScenes(View.EScenesType.EST_Login);
                        SetStateTo(GameStateType.GS_Loading);
                    }
                   
                    break;
            }
        }

        private void SdkLogOff()
        {
            GameMethod.LogOutToLogin();
            SetStateTo(GameStateType.GS_Login);
        }
    }

 

  public class HeroCtrl : Singleton<HeroCtrl>
    {
        public void Enter()
        {
            HeroCtrl.Instance.SetSelectState(HeroCtrl.HeroSelectState.EnterSelect);
            EventCenter.Broadcast(EGameEvent.eGameEvent_HeroEnter);
        }

        public void Exit()
        {
            EventCenter.Broadcast(EGameEvent.eGameEvent_HeroExit);

            if (mAudioSource != null)
                mAudioSource.Stop();
        }

		public void SetSelectState(HeroSelectState state){
			selectState = state;
			switch(state){
			case HeroSelectState.InitSelect:
				Init();
				break;
			case HeroSelectState.EnterSelect:
				EnterSelectHero();
				break;
			case HeroSelectState.RandomSelect:
				EnterRandomHero();
				break;
			case HeroSelectState.OutSelect:
				//Exit();
                Debug.LogError("HeroSelectState.OutSelect");
				break;
			}
		}

		public void AddPreSelectHero(uint index,int heroId)
        {
            //玩家预选择英雄
			foreach(var item in PlayerManager.Instance.AccountDic.Values){
				if(index == item.GameUserSeat){
					if(heroSelectDic.ContainsKey(item)){
						heroSelectDic.Remove(item);
					}
					heroSelectDic.Add(item,heroId);
					break;
				}
			}

            EventCenter.Broadcast(EGameEvent.eGameEvent_HeroPreSelect);
			
        }

		public void AddRealSelectHero(uint index,int heroId)
        {
            //玩家确定英雄
			foreach(var item in PlayerManager.Instance.AccountDic.Values){
                if (index != item.GameUserSeat){
                    continue;
                }
				if(heroSelectDic.ContainsKey(item)){
					heroSelectDic.Remove(item);
				}
                if (index == PlayerManager.Instance.LocalAccount.GameUserSeat)
                {
                    if (selectState == HeroSelectState.RandomSelect) {
                        EventCenter.Broadcast<int>(EGameEvent.eGameEvent_HeroRealSelect, heroId);
                    }
                    else {
                        PlayLocalSelectSound(heroId);
                    }
                }
				heroSureSelectDic.Add(item,heroId);
				heroSelectDic.Add(item,heroId);

				break;				
			}

            EventCenter.Broadcast(EGameEvent.eGameEvent_HeroAddSelect);
		}

        public void ReconnectPreSelect(int heroId)
        {
            EventCenter.Broadcast<int>(EGameEvent.eGameEvent_HeroReconnectPreSelect,heroId);
        }

       private void Init(){
			heroSelectDic = new Dictionary<Iplayer, int>();			
			heroSureSelectDic = new Dictionary<Iplayer, int>();	
			heroInfoList = new List<HeroSelectConfigInfo>();
			for(int i= 0 ;i < ConfigReader.HeroSelectXmlInfoDict.Count;i++)
			{
				#region 获得所有英雄信息
				HeroSelectConfigInfo item = ConfigReader.HeroSelectXmlInfoDict.ElementAt(i).Value;
                if (item.IsGuideHero == 1)
                    continue;
				heroInfoList.Add(item);
				#endregion
			}
            SortByBuyed();            
		}

        void SortByBuyed() {
            for (int i = 0; i < heroInfoList.Count; i++)
            {
                for (int j = 0; j < heroInfoList.Count - 1 - i; j++)
                {
                    HeroSelectConfigInfo infoA = heroInfoList[j];
                    HeroSelectConfigInfo infoB = heroInfoList[j + 1];
                    if (!GameUserModel.Instance.CanChooseHeroList.Contains(infoA.HeroSelectNum) && GameUserModel.Instance.CanChooseHeroList.Contains(infoB.HeroSelectNum))
                    {
                        HeroSelectConfigInfo temp = heroInfoList[j];
                        heroInfoList[j] = heroInfoList[j + 1];
                        heroInfoList[j + 1] = temp;
                    }
                }
            }
        }

		private void EnterSelectHero()
        {
			heroSelectDic.Clear();
			heroSureSelectDic.Clear(); 
		}
		
        
		private void EnterRandomHero()
        {
            //AudioClip clip = Resources.Load(AudioDefine.PATH_HERO_SELECT_COUNTDOWN) as AudioClip;
            ResourceUnit clipUnit = ResourcesManager.Instance.loadImmediate(AudioDefine.PATH_HERO_SELECT_COUNTDOWN, ResourceType.ASSET);
            AudioClip clip = clipUnit.Asset as AudioClip;
            mAudioSource = AudioManager.Instance.PlayEffectAudio(clip);

            EventCenter.Broadcast(EGameEvent.eGameEvent_HeroEnterRandom);
		}
		
		//private void Exit(){
            //senlin
			//if(UISelectHero.Instance != null){
			//	UISelectHero.Instance.Clean();
			//}
            //LoadUiResource.LoadRes(GameMethod.GetUiCamera.transform, GameConstDefine.HeroSelectUI);
		//}


        private void PlayLocalSelectSound(int heroId) {
            HeroSelectConfigInfo info = ConfigReader.GetHeroSelectInfo(heroId);
            string path = "Audio/HeroSelect/";
            path = path + info.HeroSelectSound;
            

            //AudioClip clip = (AudioClip) Resources.Load(path) as AudioClip;
            ResourceUnit clipUnit = ResourcesManager.Instance.loadImmediate(path, ResourceType.ASSET);
            AudioClip clip = clipUnit.Asset as AudioClip;

            AudioSource source = AudioManager.Instance.PlayEffectAudio(clip);
        }


		public HeroCtrl(){
			SetSelectState(HeroSelectState.InitSelect);
		} 


        
		#region public
		//临时选择的英雄
		public Dictionary<Iplayer,int> heroSelectDic{
			get;
			private set;
		}

		public Dictionary<Iplayer,int> heroSureSelectDic{
			get;
			private set;
		}
		//所有英雄信息
		public List<HeroSelectConfigInfo> heroInfoList{
			get;
			private set;
		}

		public enum HeroSelectState{
			InitSelect,
			EnterSelect,
			RandomSelect,
			OutSelect
		}
		#endregion

		#region private
		HeroSelectState selectState = HeroSelectState.InitSelect ;
        AudioSource mAudioSource = null;
		#endregion
	}

 public class HeroWindow : BaseWindow
    {

        public HeroWindow()
        {
            mScenesType = EScenesType.EST_Login;
            mResName = GameConstDefine.HeroSelectUI;
            mResident = false;
        }

        ////////////////////////////继承接口/////////////////////////
        //类对象初始化
        public override void Init()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_HeroEnter, Show);
            EventCenter.AddListener(EGameEvent.eGameEvent_HeroExit, Hide);

            EventCenter.AddListener<int>(EGameEvent.eGameEvent_HeroFirstTime, SetFirstTime);
            EventCenter.AddListener<int>(EGameEvent.eGameEvent_HeroSecondTime, SetSecondTime);
        }

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

            EventCenter.RemoveListener<int>(EGameEvent.eGameEvent_HeroFirstTime, SetFirstTime);
            EventCenter.RemoveListener<int>(EGameEvent.eGameEvent_HeroSecondTime, SetSecondTime);
        }

        //窗口控件初始化
        protected override void InitWidget()
        {
            mMidShow = mRoot.FindChild("Animator_Area");
            mLockList.Clear();
            mHeroShowList.Clear();
            mSpriteBlackList.Clear();
            for (int i = 0; i < HeroCtrl.Instance.heroInfoList.Count; i++)
            {
                #region  加载选择英雄显示预设
                GameObject objLoad = null;
                //objLoad = GameObject.Instantiate(Resources.Load(GameConstDefine.HeroShowBoxUI)) as GameObject;

                ResourceUnit objUnit = ResourcesManager.Instance.loadImmediate(GameConstDefine.HeroShowBoxUI, ResourceType.PREFAB);
                objLoad = GameObject.Instantiate(objUnit.Asset) as GameObject;

                objLoad.transform.parent = mMidShow.FindChild("HeroBox").FindChild("Grid");
                objLoad.transform.localScale = Vector3.one;
                objLoad.transform.localPosition = Vector3.zero;
                objLoad.name = "HeroBox" + (i + 1).ToString();

                UIToggle toggle = objLoad.GetComponent<UIToggle>();
                toggle.group = mHeroShowGroup;
                mHeroShowList.Add(toggle);
                #endregion

                #region 显示英雄选择ICON图片
                //black
                mShowAlpha = mRoot.FindChild("Animator_Area");
                Transform selecParent = objLoad.transform.FindChild("HeroThumbnails");
                mSpriteBlackList.Add(selecParent.FindChild("Clip").GetComponent<UISprite>());
                //head
                UISprite sprite = selecParent.FindChild("Head").GetComponent<UISprite>();
                sprite.spriteName = HeroCtrl.Instance.heroInfoList[i].HeroSelectHead.ToString();
                //lock
                Transform lockT = objLoad.transform.FindChild("Lock");
                lockT.gameObject.SetActive(false);
                mLockList.Add(lockT);
                #endregion

            }
            #region 获得描述预设
            Transform desParent = mMidShow.FindChild("HeroDestribe");
            mHeroName = desParent.FindChild("Name").FindChild("Label").GetComponent<UILabel>();
            Transform skillTran = desParent.FindChild("Skill");
            mSkillDes = skillTran.FindChild("Instruction").GetComponent<UILabel>();
            mSkillDes2 = skillTran.FindChild("Instruction2").GetComponent<UILabel>();
            mSkillDes3 = skillTran.FindChild("Instruction3").GetComponent<UILabel>();
            mSpriteDes = desParent.FindChild("Portrait").FindChild("Sprite").GetComponent<UISprite>();
            mSkilltex = skillTran.FindChild("Icon1").GetComponent<UISprite>();
            mSkilltex1 = skillTran.FindChild("Icon2").GetComponent<UISprite>();
            mSkilltex2 = skillTran.FindChild("Icon3").GetComponent<UISprite>();
            #endregion

            #region 获得英雄头像预设
            mTeamLeft = mRoot.FindChild("TeamSelectInfo");
            mTeamRight = mRoot.FindChild("EnemySelectInfo");
            int index = 1;
            for (int j = 0; j < mHeroCount; j++)
            {

                Transform teamParent = null;
                if (j % 2 == 0)
                {  //左边三个 j = 0,2,4 , i = 1,2,3			 
                    teamParent = mTeamLeft;
                }
                else
                {//右边三个 j = 1,3,5, i = 1,2,3				 
                    teamParent = mTeamRight;
                }

                Transform parent = teamParent.FindChild("Player" + index.ToString());
                mSpriteDic[j] = parent.FindChild("Thumbnail").GetComponent<UISprite>();
                mLabelName[j] = parent.FindChild("Name").GetComponent<UILabel>();
                mLabelName[j].text = "";
                mSpriteSelectDic[j] = parent.FindChild("Frame").GetComponent<UISprite>();
                mLabelDic[j] = parent.FindChild("ConfirmBar");

                if (j % 2 != 0)
                {
                    index += 1;
                }
            }
            #endregion

            #region 确定
            mBtnSure = mMidShow.FindChild("ConfirmButton").GetComponent<ButtonOnPress>();
            mObjHightLight = mBtnSure.transform.FindChild("Highlight").gameObject;
            mObjCanPress = mBtnSure.transform.FindChild("Show").gameObject;
            #endregion


            #region 购买界面
            mBuyParent = mRoot.FindChild("SureToBuyHero");
            Transform buyParentHero = mBuyParent.FindChild("Hero");
            mSpriteBuyDes = buyParentHero.FindChild("Portrait").GetComponent<UISprite>();
            mLabelBuyName = buyParentHero.FindChild("Name").GetComponent<UILabel>(); ;
            mLabelBuySkill = buyParentHero.FindChild("Skill").FindChild("Instruction").GetComponent<UILabel>();
            mLabelBuyDes = buyParentHero.FindChild("Story").GetComponent<UILabel>();
            mBtnCloseBuy = mBuyParent.FindChild("Background").GetComponent<ButtonOnPress>();
            mBtnBuy = mBuyParent.FindChild("Buy").GetComponent<ButtonOnPress>();

            //符文
            mSkinsToggle = mRoot.FindChild("TurnPage/SelectSkins").GetComponent<UIToggle>();
            mSkinsDisable = mRoot.FindChild("TurnPage/SelectSkins/Disable").gameObject;
            mSkinsSubmit = mRoot.FindChild("SkinsInterface/ConfirmButton").GetComponent<UIButton>();
            mRunePages = mRoot.FindChild("SkinsInterface/RunePages").GetComponent<UIPopupList>();

            mSkinsHeroName = mRoot.FindChild("SkinsInterface/DefaultSkin/NamePlate/Name").GetComponent<UILabel>();
            mSkinsHeroIcon = mRoot.FindChild("SkinsInterface/DefaultSkin/Portrait").GetComponent<UISprite>();

            EventDelegate.Add(mRunePages.onChange, OnRunePageChange);
            #endregion


            #region 倒计时
            for (int i = 0; i < 2; i++)
            {
                mSpriteTens[i] = mRoot.FindChild("TopBar" + (i + 1).ToString()).FindChild("Minute1").GetComponent<UISprite>();
                mSpriteUnits[i] = mRoot.FindChild("TopBar" + (i + 1).ToString()).FindChild("Minute2").GetComponent<UISprite>();
            }

            SetTime(0, mFirstCountTime);
            SetTime(1, mSecondCountTime);

            #endregion


            mArrowUpDown[0] = mMidShow.transform.FindChild("Arrow/Left");
            mArrowUpDown[1] = mMidShow.transform.FindChild("Arrow/Right");
            mScrollView = mMidShow.transform.FindChild("HeroBox").GetComponent<UIScrollView>();

            //这里出发发送服务器记录的ui点击事件消息
            SendUIEventMsg();
        }

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

        }


        //游戏事件注册
        protected override void OnAddListener()
        {
            EventCenter.AddListener(EGameEvent.eGameEvent_HeroPreSelect, UpdateHeroListSelect);
            EventCenter.AddListener<int>(EGameEvent.eGameEvent_HeroRealSelect, HeroSelect);
            EventCenter.AddListener(EGameEvent.eGameEvent_HeroAddSelect, HeroAddSelect);
            EventCenter.AddListener(EGameEvent.eGameEvent_HeroEnterRandom, RandomSelectHero);
            EventCenter.AddListener<int>(EGameEvent.eGameEvent_HeroReconnectPreSelect, UpdateReconnectPreSelect);
        }

        //游戏事件注消
        protected override void OnRemoveListener()
        {
            EventCenter.RemoveListener(EGameEvent.eGameEvent_HeroPreSelect, UpdateHeroListSelect);
            EventCenter.RemoveListener<int>(EGameEvent.eGameEvent_HeroRealSelect, HeroSelect);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_HeroAddSelect, HeroAddSelect);
            EventCenter.RemoveListener(EGameEvent.eGameEvent_HeroEnterRandom, RandomSelectHero);
            EventCenter.RemoveListener<int>(EGameEvent.eGameEvent_HeroReconnectPreSelect, UpdateReconnectPreSelect);
        }

        //显示
        public override void OnEnable()
        {
            SetSelectHeroState(SelectHeroState.InitSelect);
            ShowPlayerNickName();
            mArrowUpDown[0].gameObject.SetActive(false);
            mArrowUpDown[1].gameObject.SetActive(true);
            mScrollView.onDragFinished += OnDragFinished;
            IGuideTaskManager.Instance.SendTaskEnd(EGameEvent.eGameEvent_UIGuideRoomBeginBtnEnd);
        }

        //隐藏
        public override void OnDisable()
        {
            //UIGuide
            IGuideTaskManager.Instance.RemoveTaskStartListerner(EGameEvent.eGameEvent_UIGuideSelectHeroHeadStart, StartIGuideTask);
            IGuideTaskManager.Instance.RemoveTaskStartListerner(EGameEvent.eGameEvent_UIGuideSelectHeroCommitStart, StartIGuideTask);

            mScrollView.onDragFinished -= OnDragFinished;
            mFirstCountTime = 60;
            mSecondCountTime = 10;
        }


        public enum SelectHeroState
        {
            InitSelect,
            EnterSelect,
            InSelect,
            RandomSelect,
            OutSelect,
        }

        private SelectHeroState mSeletState = SelectHeroState.InitSelect;

        #region 可供选择
        private List<UIToggle> mHeroShowList = new List<UIToggle>(); //点击选择框
        private List<UISprite> mSpriteBlackList = new List<UISprite>();
        private List<Transform> mLockList = new List<Transform>();
        private int mSelectIndex = -1;
        #endregion

        #region 英雄头像
        Transform mTeamLeft;
        Transform mTeamRight;
        private UISprite[] mSpriteDic = new UISprite[mHeroCount]; //玩家英雄头像显示
        private UISprite[] mSpriteSelectDic = new UISprite[mHeroCount]; //玩家英雄头像显示
        private Transform[] mLabelDic = new Transform[mHeroCount];//玩家英雄头像显示
        private UILabel[] mLabelName = new UILabel[mHeroCount];

        UITweener mTween1;
        UITweener mTween2;
        UITweener mTweenAlpha;

        private UISprite mSkilltex;
        private UISprite mSkilltex1;
        private UISprite mSkilltex2;
        #endregion

        #region 描述
        private UISprite mSpriteDes;
        private UILabel mHeroName;
        private UILabel mSkillDes;
        private UILabel mSkillDes2;
        private UILabel mSkillDes3;
        #endregion

        #region 按钮
        private ButtonOnPress mBtnSure;
        private ButtonOnPress mBtnCloseBuy;
        private ButtonOnPress mBtnBuy;
        private GameObject mObjHightLight;
        private GameObject mObjCanPress;

        private UIToggle mSkinsToggle;
        private GameObject mSkinsDisable;
        private UIButton mSkinsSubmit;
        private UIPopupList mRunePages;

        private UILabel mSkinsHeroName;
        private UISprite mSkinsHeroIcon;

        #endregion

        #region 购买英雄界面
        UISprite mSpriteBuyDes;
        UILabel mLabelBuyName;
        UILabel mLabelBuySkill;
        UILabel mLabelBuyDes;
        Transform mBuyParent;
        #endregion

        #region Top
        UISprite[] mSpriteTens = new UISprite[2];
        UISprite[] mSpriteUnits = new UISprite[2];
        #endregion


        private Iplayer mLocalPlayer;
        private bool mStartCount = false;

        #region 倒计时的时间
        public static int mFirstCountTime = 60;
        public static int mSecondCountTime = 10;
        private Vector3 mTweenScaleVector = new Vector3(1.5f, 1.5f, 1f);//倒计时缩放
        private DateTime mStartTime;
        #endregion

        #region const
        private const int mTopBarTotalCount = 2;
        private const int mHeroCount = 6;
        private const int mHeroShowGroup = 2;
        private const float mMove = 50f;
        #endregion


        #region 中路顯示
        Transform mMidShow;
        Transform mShowAlpha;
        #endregion


        Transform[] mArrowUpDown = new Transform[2];
        UIScrollView mScrollView;
        void SetBtnSure(bool isVlb)
        {
            mBtnSure.gameObject.SetActive(isVlb);
            mBtnSure.enabled = isVlb;
        }
        #region 设置英雄选择界面状态
        public void SetSelectHeroState(SelectHeroState state)
        {
            mSeletState = state;
            switch (mSeletState)
            {
                case SelectHeroState.InitSelect:
                    for (int j = 0; j < mLabelDic.Length; j++)
                    {
                        mLabelDic[j].gameObject.SetActive(false);
                    }
                    EnabledSurePress(false);
                    for (int i = 0; i < mHeroShowList.Count; i++)
                    {
                        EventDelegate.Add(mHeroShowList[i].onChange, OnSelectHero);
                    }
                    mBtnSure.AddListener(OnCommitHero);
                    mBtnCloseBuy.AddListener(CloseBuy);
                    mBtnBuy.AddListener(BuyHero);
                    mLocalPlayer = PlayerManager.Instance.LocalAccount;
                    InitFlash();
                    InitRunePageList();
                    break;
                case SelectHeroState.EnterSelect:
                    EnterSelectHero();
                    break;
                case SelectHeroState.RandomSelect:
                    RandomSelectHero();
                    break;
                case SelectHeroState.OutSelect:
                    OutSelectHero();
                    break;
            }
        }
        #endregion

        #region 预选择英雄显示
        public void UpdateHeroListSelect()
        {//刷新选择列表

            foreach (var pic in mSpriteBlackList)
            {
                pic.gameObject.SetActive(false);
            }

            foreach (var item in HeroCtrl.Instance.heroSelectDic.Keys)
            {
                int heroId = 0;
                if (!HeroCtrl.Instance.heroSelectDic.TryGetValue(item, out heroId))
                    continue;
                if (item.GameUserSeat != mLocalPlayer.GameUserSeat && mLocalPlayer.IsSameCamp(item))
                {//找到队友所选择的英雄
                    int index = GetSelectIndexBuyHeroId(heroId);
                    mSpriteBlackList[index].gameObject.SetActive(true);
                }

                mSpriteDic[(int)item.GameUserSeat - 1].spriteName = ConfigReader.GetHeroSelectInfo(heroId).HeroSelectHead.ToString();
                if (item == PlayerManager.Instance.LocalAccount)
                {
                    mSpriteSelectDic[(int)item.GameUserSeat - 1].spriteName = "329";
                }
                if (!mSpriteSelectDic[(int)item.GameUserSeat - 1].gameObject.activeInHierarchy)
                {
                    mSpriteSelectDic[(int)item.GameUserSeat - 1].gameObject.SetActive(true);
                }
            }
        }

        void ShowPlayerNickName()
        {
            foreach (var item in PlayerManager.Instance.AccountDic.Values)
            {
                int index = (int)item.GameUserSeat - 1;
                if (index >= mLabelName.Length)
                    continue;
                mLabelName[index].text = item.GameUserNick;
            }
        }
        #endregion

        #region 更新左右两边队伍是否选择英雄的显示
        public void UpdateSureSelect()
        {//刷新左右两边队伍是否已经选择
            for (int i = 0; i < mHeroCount; i++)
            {
                mLabelDic[i].gameObject.SetActive(false);
            }
            foreach (var item in PlayerManager.Instance.AccountDic.Values)
            {
                if (HeroCtrl.Instance.heroSureSelectDic.ContainsKey(item))
                {
                    mLabelDic[(int)item.GameUserSeat - 1].gameObject.SetActive(true);
                    if (!mSpriteSelectDic[(int)item.GameUserSeat - 1].gameObject.activeInHierarchy)
                    {
                        mSpriteSelectDic[(int)item.GameUserSeat - 1].gameObject.SetActive(true);
                    }
                }
            }
            if (HeroCtrl.Instance.heroSureSelectDic.ContainsKey(PlayerManager.Instance.LocalAccount))
            {
                //更新英雄头像和名称，皮夫选择里面
                int id = HeroCtrl.Instance.heroSureSelectDic[PlayerManager.Instance.LocalAccount];

                HeroSelectConfigInfo config = new HeroSelectConfigInfo();
                if (ConfigReader.HeroSelectXmlInfoDict.TryGetValue(id, out config))
                {
                    mSkinsHeroName.text = config.HeroSelectNameCh;
                    mSkinsHeroIcon.spriteName = config.HeroSelectHead.ToString();
                }

                //按钮控制
                if (!mBtnSure.enabled)
                    return;
                EnabledSurePress(false);
            }           
        }
        #endregion

        #region 更新英雄选择栏的英雄锁定显示
        private void UpdateLock()
        {//显示锁定框
            for (int i = 0; i < HeroCtrl.Instance.heroInfoList.Count; i++)
            {
                if (!GameUserModel.Instance.CanChooseHeroList.Contains(HeroCtrl.Instance.heroInfoList[i].HeroSelectNum))
                {
                    mLockList[i].gameObject.SetActive(true);
                }
                else
                {
                    mLockList[i].gameObject.SetActive(false);
                }
            }
        }
        #endregion



        void OnDragFinished()
        {
            Vector3 constraint = mScrollView.panel.CalculateConstrainOffset(mScrollView.bounds.min, mScrollView.bounds.max);
            if (mScrollView.RestrictWithinBounds(false, false, true))
            {
                if (constraint.y > 0f)//上到头
                {
                    mArrowUpDown[0].gameObject.SetActive(false);
                    mArrowUpDown[1].gameObject.SetActive(true);
                }
                else//左到头
                {
                    mArrowUpDown[0].gameObject.SetActive(true);
                    mArrowUpDown[1].gameObject.SetActive(false);
                }
            }
            else
            {
                mArrowUpDown[0].gameObject.SetActive(true);
                mArrowUpDown[1].gameObject.SetActive(true);
            }
        }
        #region InitFlash
        void InitFlash()
        {
            UpdateLock();
            Vector3 orginalLeft = mTeamLeft.localPosition;
            Vector3 orginalRight = mTeamRight.localPosition;
            mTeamLeft.localPosition = new Vector3(orginalLeft.x - mMove, orginalLeft.y, orginalLeft.z);
            mTeamRight.localPosition = new Vector3(orginalRight.x + mMove, orginalRight.y, orginalRight.z);

            mTween1 = TweenPosition.Begin(mTeamLeft.gameObject, 0.5f, orginalLeft);
            mTween2 = TweenPosition.Begin(mTeamRight.gameObject, 0.5f, orginalRight);
            UICommonMethod.TweenAlphaBegin(mShowAlpha.gameObject, 0f, 0f);
            mTweenAlpha = UICommonMethod.TweenAlphaBegin(mShowAlpha.gameObject, 1.7f, 1f);
            mTween1.method = UITweener.Method.EaseIn;
            mTween2.method = UITweener.Method.EaseIn;
            mSelectIndex = -1;
            //  EventDelegate.Add(tweenAlpha.onFinished, FinishTween);
            SetSelectHeroState(SelectHeroState.EnterSelect);
            //  EnableToggle(false);
        }
        #endregion


        #region
        void EnableToggle(bool enable)
        {
            foreach (var item in mHeroShowList)
            {
                item.enabled = enable;
            }
        }
        #endregion



        #region 进入选择英雄阶段
        private void EnterSelectHero()
        {
            MsgInfoManager.Instance.ShowMsg(10);
            SetBtnSure(true);
            EnableToggle(true);
            FirstCountDown();
            SetSelectHeroState(SelectHeroState.InSelect);

            //UIGuide
            IGuideTaskManager.Instance.AddTaskStartListerner(EGameEvent.eGameEvent_UIGuideSelectHeroHeadStart, StartIGuideTask);
            IGuideTaskManager.Instance.AddTaskStartListerner(EGameEvent.eGameEvent_UIGuideSelectHeroCommitStart, StartIGuideTask);
            IGuideTaskManager.Instance.SendTaskTrigger(EGameEvent.eGameEvent_UIGuideTriggerSelectHero);
        }
        #endregion

        void StartIGuideTask(EGameEvent taskId)
        {
            IGuideTaskManager.Instance.SendTaskEffectShow(taskId);
        }



        #region 进入最后随机阶段
        private void RandomSelectHero()
        {
            IGuideTaskManager.Instance.SendTaskEnd(EGameEvent.eGameEvent_UIGuideSelectHeroHeadEnd);
            IGuideTaskManager.Instance.SendTaskEnd(EGameEvent.eGameEvent_UIGuideSelectHeroCommitEnd);
            EnabledSurePress(false);
            TweenRotation obj = mSpriteUnits[0].transform.parent.GetComponent<TweenRotation>();
            obj.enabled = true;
            //UITweener tween = TweenRotation.Begin(obj, 1f, Quaternion.EulerRotation(180f, 0f, 0f));
            obj.method = UITweener.Method.EaseOut;
            EventDelegate.Add(obj.onFinished, LastCountDown);

            mSkinsDisable.gameObject.SetActive(false);
            mSkinsToggle.value = true;
        }
        #endregion

        #region 倒计时



        private void SetTime(int step, int time)
        {
            int ten = time / 10;
            int unit = time % 10;
            if (step == 0)
            {
                unit = unit + 10;
            }
            if (ten == 0)
            {
                mSpriteTens[step].gameObject.SetActive(false);
            }
            else
            {
                mSpriteTens[step].gameObject.SetActive(true);
                if (step == 0)
                {
                    ten = ten + 10;
                }
                mSpriteTens[step].spriteName = ten.ToString();
            }

            mSpriteUnits[step].spriteName = unit.ToString();

        }

        private void FirstCountDown()
        {
            if (mFirstCountTime == 0)
            {
                return;
            }
            SetTime(0, mFirstCountTime);
            mStartTime = DateTime.Now;
            mStartCount = true;
            mSpriteTens[1].transform.parent.gameObject.SetActive(false);
        }

        private void LastCountDown()
        {
            mStartTime = DateTime.Now;
            mStartCount = true;
            mSpriteTens[0].transform.parent.gameObject.SetActive(false);
            mSpriteTens[1].transform.parent.gameObject.SetActive(true);

            SetSelectHeroState(SelectHeroState.RandomSelect);
        }

        UITweener scaleTween;
        private void TweenCountDownLabelScale(GameObject obj)
        {
            TweenAlpha.Begin(obj.gameObject, 0f, 1f);
            TweenScale.Begin(obj, 0f, mTweenScaleVector);
            scaleTween = TweenScale.Begin(obj, 0.5f, new Vector3(1f, 1f, 1f));
            scaleTween.method = UITweener.Method.EaseInOut;
            EventDelegate.Add(scaleTween.onFinished, FinshTweenScale, true);
        }

        void FinshTweenScale()
        {
            EventDelegate.Remove(scaleTween.onFinished, FinshTweenScale);
        }
        void SetSecondTimeDown()
        {
            SetTime(1, mSecondCountTime);
            TweenCountDownLabelScale(mSpriteUnits[1].gameObject);
        }
        public override void Update(float deltaTime)
        {
            if (mStartCount)
            {
                TimeSpan span = DateTime.Now - mStartTime;
                if (span.TotalSeconds <= 1f)
                    return;
                mStartTime = DateTime.Now;
                if (mSeletState == SelectHeroState.RandomSelect)
                {
                    mSecondCountTime = mSecondCountTime - (int)span.TotalSeconds;
                    if (mSecondCountTime < 0)
                    {
                        mStartCount = false;
                        return;
                    }
                    SetSecondTimeDown();
                }
                else
                {
                    mFirstCountTime = mFirstCountTime - (int)span.TotalSeconds;
                    if (mFirstCountTime < 0)
                    {
                        mStartCount = false;
                        return;
                    }
                    SetTime(0, mFirstCountTime);
                }
            }
        }
        #endregion

        #region 结束选择英雄
        private void OutSelectHero()
        {
            for (int i = 0; i < mHeroShowList.Count; i++)
            {
                EventDelegate.Add(mHeroShowList[i].onChange, OnSelectHero);
            }
            mBtnSure.RemoveListener(OnCommitHero);
            mBtnCloseBuy.RemoveListener(CloseBuy);
            mBtnBuy.RemoveListener(BuyHero);
            mStartCount = false;
        }
        #endregion

        #region 结束入场动画
        private void FinishTween()
        {
            //  SetSelectHeroState(SelectHeroState.EnterSelect);		
        }
        #endregion


        #region 点击购买英雄
        private void BuyHero(int ie, bool press)
        {
            if (press || mSeletState == SelectHeroState.InitSelect)
            {
                return;
            }
        }
        #endregion

        #region 关闭购买英雄
        private void CloseBuy(int ie, bool press)
        {
            if (press)
            {
                return;
            }
            //buyParent.gameObject.SetActive(false);
        }
        #endregion

        #region 点击确定选择英雄按钮事件
        private void OnCommitHero(int ie, bool press)
        {
            EnabledSurePress(false);
            if (press || mSeletState != SelectHeroState.InSelect)
            {
                return;
            }
            if (mSelectIndex != -1)
            {
                IGuideTaskManager.Instance.SendTaskEnd(EGameEvent.eGameEvent_UIGuideSelectHeroCommitEnd);
                CGLCtrl_GameLogin.Instance.EmsgToss_AskSelectHero((UInt32)HeroCtrl.Instance.heroInfoList.ElementAt(mSelectIndex).HeroSelectNum);

                mSkinsDisable.gameObject.SetActive(false);
                mSkinsToggle.value = true;
            }
        }
        #endregion

        #region 点击英雄栏的选择事件
        void OnSelectHero()
        {
            UIToggle toggle = UIToggle.current;
            if (toggle != null && toggle.group == mHeroShowGroup && toggle.value)
            {
                for (int i = 0; i < mHeroShowList.Count; i++)
                {
                    if (mHeroShowList[i] != toggle)
                        continue;
                    mSelectIndex = i;
                    ShowDestribe(i);//描述 
                    if (UpdateSureBtn(i))
                    {//是否可点击
                        IGuideTaskManager.Instance.SendTaskEnd(EGameEvent.eGameEvent_UIGuideSelectHeroHeadEnd);
                        NotifyServerMyPreSelect(i);
                    }
                    break;
                }
            }
        }

        public void UpdateReconnectPreSelect(int heroId)
        {
            int index = GetSelectIndexBuyHeroId(heroId);
            mSelectIndex = index;
            ShowDestribe(index);//描述 
            SetSelectShow(index);
        }


        #endregion

        #region 更新按钮状态并判断是否可点击选择按钮
        bool UpdateSureBtn(int index)
        {
            bool canPress = true;
            int id = HeroCtrl.Instance.heroInfoList[index].HeroSelectNum;
            if (!TeamMateHasSelectHero(id) && GameUserModel.Instance.CanChooseHeroList.Contains(id)
               && mSeletState == SelectHeroState.InSelect
               && !HeroCtrl.Instance.heroSureSelectDic.ContainsKey(PlayerManager.Instance.LocalAccount))
            {
                canPress = true;
            }
            else
            {
                canPress = false;
            }
            EnabledSurePress(canPress);
            return canPress;
        }
        #endregion

        #region 设置按钮可不可选择显示
        void EnabledSurePress(bool enable)
        {
            mBtnSure.GetComponent<BoxCollider>().enabled = enable;
            mObjHightLight.gameObject.SetActive(!enable);
            mObjCanPress.gameObject.SetActive(enable);
        }
        #endregion

        #region 通知客户端点击的英雄
        void NotifyServerMyPreSelect(int index)
        {
            int id = HeroCtrl.Instance.heroInfoList[index].HeroSelectNum;
            CGLCtrl_GameLogin.Instance.EmsgTocs_TryToSelectHero((uint)id);
        }
        #endregion

        #region 通过点击的是第几个英雄显示英雄信息
        void ShowDestribe(int index)
        {
            ShowHasDes(index);
            if (!GameUserModel.Instance.CanChooseHeroList.Contains(HeroCtrl.Instance.heroInfoList[index].HeroSelectNum))
            {
                ShowBuyeDes(index);
            }
        }
        #endregion

        #region 通过点击的是第几个英雄显示已购买英雄信息
        public void ShowHasDes(int index)
        {
            mHeroName.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectNameCh;
            mSpriteDes.spriteName = HeroCtrl.Instance.heroInfoList[index].HeroSelectThumb;
            mSkillDes.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectDes;
            mSkillDes2.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectDes2;
            mSkillDes3.text = HeroCtrl.Instance.heroInfoList[index].HeroPassDes;
            mSkilltex.spriteName = HeroCtrl.Instance.heroInfoList[index].HeroSelectSkill1;
            mSkilltex1.spriteName = HeroCtrl.Instance.heroInfoList[index].HeroSelectSkill2;
            mSkilltex2.spriteName = HeroCtrl.Instance.heroInfoList[index].HeroSkillPass;
        }
        #endregion

        #region 通过点击的是第几个英雄显示购买描述
        void ShowBuyeDes(int index)
        {
            return;
            mLabelBuyName.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectNameCh;
            mSpriteBuyDes.spriteName = HeroCtrl.Instance.heroInfoList[index].HeroSelectThumb;
            mLabelBuySkill.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectDes;
            mLabelBuyDes.text = HeroCtrl.Instance.heroInfoList[index].HeroSelectBuyDes;
            mBuyParent.gameObject.SetActive(true);
        }
        #endregion

        #region 通过英雄ID号获得选择的是第几个英雄
        public int GetSelectIndexBuyHeroId(int heroId)
        {
            for (int i = 0; i < HeroCtrl.Instance.heroInfoList.Count; i++)
            {
                if (HeroCtrl.Instance.heroInfoList[i].HeroSelectNum != heroId)
                    continue;
                return i;
            }
            return -1;
        }
        #endregion


        public void SetSelectShow(int index)
        {
            mHeroShowList[index].value = true;
        }

        #region 通过英雄ID判断队友是否有选择此英雄
        private bool TeamMateHasSelectHero(int heroId)
        {
            foreach (var item in HeroCtrl.Instance.heroSelectDic.Keys)
            {
                if (item.GameUserSeat == mLocalPlayer.GameUserSeat || !mLocalPlayer.IsSameCamp(item))//找到队友所选择的英雄
                    continue;
                int heroSelect = 0;
                if (!HeroCtrl.Instance.heroSelectDic.TryGetValue(item, out heroSelect))
                    continue;
                if (heroSelect == heroId)
                    return true;
            }
            return false;
        }
        #endregion

        //英雄选择
        public void HeroSelect(int heroid)
        {
            int itemPos = GetSelectIndexBuyHeroId(heroid);
            ShowHasDes(itemPos);
            SetSelectShow(itemPos);
            MsgInfoManager.Instance.ShowMsg((int)ERROR_TYPE.eT_ObtainRandomHero);
        }

        public void HeroAddSelect()
        {
            UpdateHeroListSelect();
            UpdateSureSelect();
        }

        public void SetFirstTime(int time)
        {
            mFirstCountTime = time;
        }

        public void SetSecondTime(int time)
        {
            mSecondCountTime = time;
        }

        public void OnRunePageChange()
        {
            int index = mRunePages.data == null ? 0 : (int)mRunePages.data;

            CGLCtrl_GameLogin.Instance.EmsgToss_AskChangeRunePage(index);
        }

        public void InitRunePageList()
        {
            mRunePages.items.Clear();
            mRunePages.itemData.Clear();
            int page = RuneEquipModel.Instance.pagenum + 1;

            for (int i = 0; i < page; i++)
            {
                mRunePages.items.Add(ConfigReader.GetMsgInfo(40050).content + (i + 1));
                mRunePages.itemData.Add(i);
            }
        }
        //这里出发发送服务器记录的ui点击事件消息
        public void SendUIEventMsg()
        {
            CGLCtrl_GameLogin.Instance.EmsgTocs_ReportUIEvent();
        }
    }