+scripts

1 files changed, 764 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/XMainInterfaceDocument.cs b/Client/Assets/Scripts/XMainClient/XMainInterfaceDocument.cs
new file mode 100644
index 00000000..543505b2
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/XMainInterfaceDocument.cs
@@ -0,0 +1,764 @@
+using System;

+using System.Collections;

+using KKSG;

+using UILib;

+using UnityEngine;

+using XMainClient.UI;

+using XMainClient.UI.UICommon;

+using XUtliPoolLib;

+

+namespace XMainClient

+{

+	internal class XMainInterfaceDocument : XDocComponent

+	{

+		public override uint ID

+		{

+			get

+			{

+				return XMainInterfaceDocument.uuID;

+			}

+		}

+

+		public GameCommunityTable GameCommunityReader

+		{

+			get

+			{

+				return XMainInterfaceDocument._gameCommunityReader;

+			}

+		}

+

+		public XMainInterface View

+		{

+			get

+			{

+				return this._view;

+			}

+			set

+			{

+				this._view = value;

+			}

+		}

+

+		public XMainInterfaceDocument.GetFps GetFpsState

+		{

+			get

+			{

+				return this._get_fps_state;

+			}

+			set

+			{

+				this._get_fps_state = value;

+			}

+		}

+

+		public float FpsStartTime

+		{

+			get

+			{

+				return this._fps_start_time;

+			}

+			set

+			{

+				this._fps_start_time = value;

+			}

+		}

+

+		public float PeakFps

+		{

+			get

+			{

+				return this._peak_fps;

+			}

+			set

+			{

+				this._peak_fps = value;

+			}

+		}

+

+		public int FpsCount

+		{

+			get

+			{

+				return this._fps_count;

+			}

+			set

+			{

+				this._fps_count = value;

+			}

+		}

+

+		public bool GameAnnouncement

+		{

+			set

+			{

+				this._game_announcement = value;

+			}

+		}

+

+		public bool BackFlow

+		{

+			get

+			{

+				return this._backFlow;

+			}

+			set

+			{

+				this._backFlow = value;

+			}

+		}

+

+		public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("MainInterfaceDocument");

+

+		public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader();

+

+		private static GameCommunityTable _gameCommunityReader = new GameCommunityTable();

+

+		private XMainInterface _view = null;

+

+		public XEventBlocker<XAttrChangeEventArgs> AttrEventBlocker = new XEventBlocker<XAttrChangeEventArgs>();

+

+		public XEventBlocker<XVirtualItemChangedEventArgs> VirtualItemEventBlocker = new XEventBlocker<XVirtualItemChangedEventArgs>();

+

+		public XEventBlocker<XAddItemEventArgs> AddItemEventBlocker = new XEventBlocker<XAddItemEventArgs>();

+

+		public XEventBlocker<XRemoveItemEventArgs> RemoveItemEventBlocker = new XEventBlocker<XRemoveItemEventArgs>();

+

+		public XEventBlocker<XItemNumChangedEventArgs> ItemNumChangedEventBlocker = new XEventBlocker<XItemNumChangedEventArgs>();

+

+		private XMainInterfaceDocument.GetFps _get_fps_state = XMainInterfaceDocument.GetFps.wait;

+

+		private float _fps_start_time = 0f;

+

+		private float _peak_fps = 0f;

+

+		private int _fps_count = 0;

+

+		private bool _game_announcement = false;

+

+		public bool ShowWebView = false;

+

+		private bool _backFlow = false;

+

+		public enum GetFps

+		{

+			wait,

+			start,

+			running,

+			stop

+		}

+

+		public override void OnAttachToHost(XObject host)

+		{

+			base.OnAttachToHost(host);

+			this.AttrEventBlocker.EventHandler = new XEventBlocker<XAttrChangeEventArgs>.XEventHandler(this.OnAttributeChange);

+			this.VirtualItemEventBlocker.EventHandler = new XEventBlocker<XVirtualItemChangedEventArgs>.XEventHandler(this.OnVirtualItemChanged);

+			this.AddItemEventBlocker.EventHandler = new XEventBlocker<XAddItemEventArgs>.XEventHandler(this.OnAddItem);

+			this.RemoveItemEventBlocker.EventHandler = new XEventBlocker<XRemoveItemEventArgs>.XEventHandler(this.OnRemoveItem);

+			this.ItemNumChangedEventBlocker.EventHandler = new XEventBlocker<XItemNumChangedEventArgs>.XEventHandler(this.OnItemNumChanged);

+			this._get_fps_state = XMainInterfaceDocument.GetFps.start;

+		}

+

+		public static void Execute(OnLoadedCallback callback = null)

+		{

+			XMainInterfaceDocument.AsyncLoader.AddTask("Table/GameCommunity", XMainInterfaceDocument._gameCommunityReader, false);

+			XMainInterfaceDocument.AsyncLoader.Execute(callback);

+		}

+

+		protected override void EventSubscribe()

+		{

+			base.EventSubscribe();

+			base.RegisterEvent(XEventDefine.XEvent_AttributeChange, new XComponent.XEventHandler(this.OnAttributeChange));

+			base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.OnVirtualItemChanged));

+			base.RegisterEvent(XEventDefine.XEvent_AddItem, new XComponent.XEventHandler(this.OnAddItem));

+			base.RegisterEvent(XEventDefine.XEvent_RemoveItem, new XComponent.XEventHandler(this.OnRemoveItem));

+			base.RegisterEvent(XEventDefine.XEvent_ItemNumChanged, new XComponent.XEventHandler(this.OnItemNumChanged));

+			base.RegisterEvent(XEventDefine.XEvent_GuildLevelChanged, new XComponent.XEventHandler(this.OnGuildLevelChanged));

+			base.RegisterEvent(XEventDefine.XEvent_InGuildStateChanged, new XComponent.XEventHandler(this.OnInGuildStateChanged));

+			base.RegisterEvent(XEventDefine.XEvent_TeamMemberCountChanged, new XComponent.XEventHandler(this._OnMemberCountChanged));

+			base.RegisterEvent(XEventDefine.XEvent_JoinTeam, new XComponent.XEventHandler(this._OnJoinTeam));

+			base.RegisterEvent(XEventDefine.XEvent_LeaveTeam, new XComponent.XEventHandler(this._OnLeaveTeam));

+			base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange));

+		}

+

+		private bool _OnJoinTeam(XEventArgs e)

+		{

+			bool flag = this._view != null;

+			if (flag)

+			{

+				XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);

+				bool bInTeam = specificDocument.bInTeam;

+				if (bInTeam)

+				{

+					this._view._TaskNaviHandler.SetTeamMemberCount(specificDocument.MyTeam.members.Count);

+				}

+			}

+			return true;

+		}

+

+		private bool _OnLeaveTeam(XEventArgs e)

+		{

+			bool flag = this._view != null;

+			if (flag)

+			{

+				this._view._TaskNaviHandler.SetTeamMemberCount(0);

+			}

+			return true;

+		}

+

+		private bool _OnMemberCountChanged(XEventArgs arg)

+		{

+			XTeamMemberCountChangedEventArgs xteamMemberCountChangedEventArgs = arg as XTeamMemberCountChangedEventArgs;

+			bool flag = this._view != null;

+			if (flag)

+			{

+				this._view._TaskNaviHandler.SetTeamMemberCount((int)xteamMemberCountChangedEventArgs.newCount);

+			}

+			return true;

+		}

+

+		protected bool OnGuildLevelChanged(XEventArgs e)

+		{

+			bool flag = this.View != null && this.View.IsVisible();

+			if (flag)

+			{

+				this.View.OnGuildSysChange();

+			}

+			return true;

+		}

+

+		protected bool OnInGuildStateChanged(XEventArgs e)

+		{

+			XInGuildStateChangedEventArgs xinGuildStateChangedEventArgs = e as XInGuildStateChangedEventArgs;

+			bool flag = this.View != null && this.View.IsVisible();

+			if (flag)

+			{

+				this.View.OnGuildSysChange();

+			}

+			return true;

+		}

+

+		protected bool OnAttributeChange(XEventArgs e)

+		{

+			bool flag = this._view != null && this._view.IsVisible();

+			if (flag)

+			{

+				XAttrChangeEventArgs xattrChangeEventArgs = e as XAttrChangeEventArgs;

+				bool bBlockReceiver = this.AttrEventBlocker.bBlockReceiver;

+				if (bBlockReceiver)

+				{

+					XAttrChangeEventArgs @event = XEventPool<XAttrChangeEventArgs>.GetEvent();

+					@event.AttrKey = xattrChangeEventArgs.AttrKey;

+					@event.DeltaValue = xattrChangeEventArgs.DeltaValue;

+					this.AttrEventBlocker.AddEvent(@event);

+					return true;

+				}

+				XAttributeDefine attrKey = xattrChangeEventArgs.AttrKey;

+				if (attrKey == XAttributeDefine.XAttr_POWER_POINT_Basic)

+				{

+					bool flag2 = this._view.IsVisible();

+					if (flag2)

+					{

+						this._view.SetPowerpoint((int)xattrChangeEventArgs.DeltaValue);

+					}

+					DlgBase<CapacityDownDlg, CapacityBehaviour>.singleton.UpdatePPT((int)xattrChangeEventArgs.DeltaValue);

+				}

+			}

+			return true;

+		}

+

+		private IEnumerator LoadWebViewConfig(string url)

+		{

+			WWW www = new WWW(url);

+			yield return www;

+			while (!www.isDone)

+			{

+				yield return www;

+			}

+			bool flag = !string.IsNullOrEmpty(www.error);

+			if (flag)

+			{

+				this.ShowWebView = false;

+				www.Dispose();

+				yield break;

+			}

+			bool flag2 = www.text.Contains("true");

+			if (flag2)

+			{

+				this.ShowWebView = true;

+			}

+			else

+			{

+				this.ShowWebView = false;

+			}

+			www.Dispose();

+			www = null;

+			yield break;

+		}

+

+		public override void OnEnterSceneFinally()

+		{

+			base.OnEnterSceneFinally();

+			bool flag = !this._game_announcement && XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;

+			if (flag)

+			{

+				XSingleton<UiUtility>.singleton.ShowPatface();

+				this._game_announcement = true;

+			}

+			else

+			{

+				bool flag2 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;

+				if (flag2)

+				{

+					XSingleton<XPandoraSDKDocument>.singleton.CheckPandoraPLPanel();

+				}

+			}

+			bool flag3 = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;

+			if (flag3)

+			{

+				XSingleton<XUICacheMgr>.singleton.TryShowCache();

+			}

+			bool flag4 = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();

+			if (flag4)

+			{

+				DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.MulActTipsToken = XSingleton<XTimerMgr>.singleton.SetTimer(5f, new XTimerMgr.ElapsedEventHandler(DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.SetMultiActivityTips), null);

+			}

+		}

+

+		public override void OnLeaveScene()

+		{

+			base.OnEnterScene();

+			this.AttrEventBlocker.ClearEvents();

+			this.VirtualItemEventBlocker.ClearEvents();

+			this.AddItemEventBlocker.ClearEvents();

+			this.RemoveItemEventBlocker.ClearEvents();

+			this.ItemNumChangedEventBlocker.ClearEvents();

+			bool flag = this._get_fps_state == XMainInterfaceDocument.GetFps.running;

+			if (flag)

+			{

+				float num = (float)this._fps_count / (Time.realtimeSinceStartup - this._fps_start_time);

+				XSingleton<XDebug>.singleton.AddLog("TestinLog-Event>>>> ID Times, Key Average Fps, Value ", num.ToString(), null, null, null, null, XDebugColor.XDebug_None);

+				XSingleton<XDebug>.singleton.AddLog("TestinLog-Event>>>> ID Times, Key Peak Fps, Value ", this._peak_fps.ToString(), null, null, null, null, XDebugColor.XDebug_None);

+				this._get_fps_state = XMainInterfaceDocument.GetFps.stop;

+			}

+			XSingleton<XDebug>.singleton.AddGreenLog("OnLeaveScene", null, null, null, null, null);

+			XSingleton<XPandoraSDKDocument>.singleton.CloseAllPandoraPanel();

+		}

+

+		public void OnSysOpen()

+		{

+			bool flag = this._view != null;

+			if (flag)

+			{

+				this._view.RefreshSysAnnounce();

+			}

+		}

+

+		public void OnSysChange()

+		{

+			bool flag = this._view != null;

+			if (flag)

+			{

+				this._view.OnMainSysChange();

+			}

+		}

+

+		public void RefreshVirtualItem(int itemID)

+		{

+			DlgBase<TitanbarView, TitanBarBehaviour>.singleton.TryRefresh(itemID);

+			bool flag = this._view == null || !this._view.IsVisible();

+			if (!flag)

+			{

+				this._view.RefreshMoneyInfo(itemID, false);

+			}

+		}

+

+		public void OnLoadWebViewConfig()

+		{

+			int num = int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("HideWebView"));

+			bool flag = num == 1;

+			if (!flag)

+			{

+				string openID = XSingleton<XLoginDocument>.singleton.OpenID;

+				uint serverID = XSingleton<XClientNetwork>.singleton.ServerID;

+				RuntimePlatform platform = Application.platform;

+				string text;

+				if ((int)platform != 8)

+				{

+					if ((int)platform != 11)

+					{

+						text = "2";

+					}

+					else

+					{

+						text = "1";

+					}

+				}

+				else

+				{

+					text = "0";

+				}

+				bool flag2 = XSingleton<XLoginDocument>.singleton.Channel == XAuthorizationChannel.XAuthorization_QQ;

+				string text2;

+				if (flag2)

+				{

+					text2 = "2";

+				}

+				else

+				{

+					bool flag3 = XSingleton<XLoginDocument>.singleton.Channel == XAuthorizationChannel.XAuthorization_WeChat;

+					if (flag3)

+					{

+						text2 = "1";

+					}

+					else

+					{

+						bool flag4 = XSingleton<XLoginDocument>.singleton.Channel == XAuthorizationChannel.XAuthorization_Guest;

+						if (flag4)

+						{

+							return;

+						}

+						text2 = "0";

+					}

+				}

+				string text3 = string.Format(XSingleton<XGlobalConfig>.singleton.GetValue("WebviewGray"), new object[]

+				{

+					openID,

+					text2,

+					text,

+					serverID

+				});

+				XSingleton<XDebug>.singleton.AddLog("Req url: ", text3, null, null, null, null, XDebugColor.XDebug_None);

+				DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.uiBehaviour.StartCoroutine(this.LoadWebViewConfig(text3));

+			}

+		}

+

+		protected bool OnVirtualItemChanged(XEventArgs args)

+		{

+			XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs;

+			bool bBlockReceiver = this.VirtualItemEventBlocker.bBlockReceiver;

+			bool result;

+			if (bBlockReceiver)

+			{

+				this.VirtualItemEventBlocker.AddEvent(xvirtualItemChangedEventArgs.Clone() as XVirtualItemChangedEventArgs);

+				result = true;

+			}

+			else

+			{

+				DlgBase<TitanbarView, TitanBarBehaviour>.singleton.TryRefresh(xvirtualItemChangedEventArgs.itemID);

+				bool flag = this._view == null || !this._view.IsVisible();

+				if (flag)

+				{

+					result = false;

+				}

+				else

+				{

+					this._view.RefreshMoneyInfo(xvirtualItemChangedEventArgs.itemID, true);

+					result = true;

+				}

+			}

+			return result;

+		}

+

+		protected bool OnAddItem(XEventArgs args)

+		{

+			XAddItemEventArgs xaddItemEventArgs = args as XAddItemEventArgs;

+			bool bBlockReceiver = this.AddItemEventBlocker.bBlockReceiver;

+			bool result;

+			if (bBlockReceiver)

+			{

+				this.AddItemEventBlocker.AddEvent(xaddItemEventArgs.Clone() as XAddItemEventArgs);

+				result = true;

+			}

+			else

+			{

+				for (int i = 0; i < xaddItemEventArgs.items.Count; i++)

+				{

+					DlgBase<TitanbarView, TitanBarBehaviour>.singleton.TryRefresh(xaddItemEventArgs.items[i].itemID);

+					bool flag = this._view != null && this._view.IsVisible();

+					if (flag)

+					{

+						this._view.RefreshMoneyInfo(xaddItemEventArgs.items[i].itemID, true);

+					}

+				}

+				result = true;

+			}

+			return result;

+		}

+

+		protected bool OnRemoveItem(XEventArgs args)

+		{

+			XRemoveItemEventArgs xremoveItemEventArgs = args as XRemoveItemEventArgs;

+			bool bBlockReceiver = this.RemoveItemEventBlocker.bBlockReceiver;

+			bool result;

+			if (bBlockReceiver)

+			{

+				this.RemoveItemEventBlocker.AddEvent(xremoveItemEventArgs.Clone() as XRemoveItemEventArgs);

+				result = true;

+			}

+			else

+			{

+				DlgBase<TitanbarView, TitanBarBehaviour>.singleton.TryRefresh(xremoveItemEventArgs.ids);

+				bool flag = this._view == null || !this._view.IsVisible();

+				if (flag)

+				{

+					result = true;

+				}

+				else

+				{

+					for (int i = 0; i < xremoveItemEventArgs.ids.Count; i++)

+					{

+						this._view.RefreshMoneyInfo(xremoveItemEventArgs.ids[i], true);

+					}

+					result = true;

+				}

+			}

+			return result;

+		}

+

+		protected bool OnItemNumChanged(XEventArgs args)

+		{

+			XItemNumChangedEventArgs xitemNumChangedEventArgs = args as XItemNumChangedEventArgs;

+			bool bBlockReceiver = this.ItemNumChangedEventBlocker.bBlockReceiver;

+			bool result;

+			if (bBlockReceiver)

+			{

+				this.ItemNumChangedEventBlocker.AddEvent(xitemNumChangedEventArgs.Clone() as XItemNumChangedEventArgs);

+				result = true;

+			}

+			else

+			{

+				DlgBase<TitanbarView, TitanBarBehaviour>.singleton.TryRefresh(xitemNumChangedEventArgs.item.itemID);

+				bool flag = this._view == null || !this._view.IsVisible();

+				if (flag)

+				{

+					result = true;

+				}

+				else

+				{

+					this._view.RefreshMoneyInfo(xitemNumChangedEventArgs.item.itemID, true);

+					result = true;

+				}

+			}

+			return result;

+		}

+

+		public void Present()

+		{

+			this.OnTopUIRefreshed(null);

+			this._view.SetupBaseInfo(XSingleton<XEntityMgr>.singleton.Player.Attributes);

+			DlgBase<CapacityDownDlg, CapacityBehaviour>.singleton.InitPPT();

+			this._view.InitRedPointsWhenShow();

+			bool needTutorail = XSingleton<XTutorialMgr>.singleton.NeedTutorail;

+			if (needTutorail)

+			{

+				XSingleton<XTutorialMgr>.singleton.ReExecuteCurrentCmd();

+			}

+		}

+

+		public int GetPlayerPPT()

+		{

+			XPlayer player = XSingleton<XEntityMgr>.singleton.Player;

+			XPlayerAttributes xplayerAttributes = player.Attributes as XPlayerAttributes;

+			return (int)xplayerAttributes.GetAttr(XAttributeDefine.XAttr_POWER_POINT_Basic);

+		}

+

+		public ulong GetPlayerGold()

+		{

+			return XSingleton<XGame>.singleton.Doc.XBagDoc.GetVirtualItemCount(ItemEnum.GOLD);

+		}

+

+		public ulong GetPlayerDC()

+		{

+			return XSingleton<XGame>.singleton.Doc.XBagDoc.GetVirtualItemCount(ItemEnum.DRAGON_COIN);

+		}

+

+		public void OnTopUIRefreshed(IXUIDlg dlg)

+		{

+			bool flag = dlg == null;

+			if (flag)

+			{

+				bool flag2 = DlgBase<TitanbarView, TitanBarBehaviour>.singleton.IsVisible();

+				if (flag2)

+				{

+					DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetVisible(false, true);

+				}

+			}

+			else

+			{

+				int[] titanBarItems = dlg.GetTitanBarItems();

+				bool flag3 = titanBarItems != null;

+				if (flag3)

+				{

+					DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetVisible(true, true);

+					DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetTitanItems(titanBarItems);

+				}

+				else

+				{

+					bool hideMainMenu = dlg.hideMainMenu;

+					if (hideMainMenu)

+					{

+						DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetVisible(true, true);

+						DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetTitanItems((XSysDefine)dlg.sysid);

+					}

+					else

+					{

+						bool flag4 = DlgBase<TitanbarView, TitanBarBehaviour>.singleton.IsVisible();

+						if (flag4)

+						{

+							DlgBase<TitanbarView, TitanBarBehaviour>.singleton.SetVisible(false, true);

+						}

+					}

+				}

+			}

+		}

+

+		public void SetBlockItemsChange(bool bBlock)

+		{

+			this.VirtualItemEventBlocker.bBlockReceiver = bBlock;

+			this.AddItemEventBlocker.bBlockReceiver = bBlock;

+			this.RemoveItemEventBlocker.bBlockReceiver = bBlock;

+			this.ItemNumChangedEventBlocker.bBlockReceiver = bBlock;

+		}

+

+		public void SetVoiceBtnAppear(uint type)

+		{

+			bool flag = DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.IsVisible();

+			if (flag)

+			{

+				DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.OnVoiceBtnAppear(type);

+			}

+		}

+

+		public bool OnPlayerLevelChange(XEventArgs arg)

+		{

+			DlgBase<XMainInterface, XMainInterfaceBehaviour>.singleton.OnSingleSysChange(XSysDefine.XSys_SystemAnnounce, true);

+			return true;

+		}

+

+		public void OnHallIconNtfGet(HallIconPara data)

+		{

+			XSingleton<XDebug>.singleton.AddGreenLog(string.Concat(new object[]

+			{

+				"IconID: ",

+				data.systemid,

+				"\nHallIcon.state: ",

+				data.state

+			}), null, null, null, null, null);

+			bool flag = !XSingleton<XGameSysMgr>.singleton.IsSystemOpen(data.systemid);

+			if (!flag)

+			{

+				XSysDefine systemid = (XSysDefine)data.systemid;

+				if (systemid <= XSysDefine.XSys_Rank_WorldBoss)

+				{

+					if (systemid <= XSysDefine.XSys_GuildMine)

+					{

+						if (systemid == XSysDefine.XSys_Spectate)

+						{

+							XSpectateDocument specificDocument = XDocuments.GetSpecificDocument<XSpectateDocument>(XSpectateDocument.uuID);

+							specificDocument.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN, data.liveInfo);

+							return;

+						}

+						if (systemid == XSysDefine.XSys_GuildMine)

+						{

+							XGuildMineEntranceDocument specificDocument2 = XDocuments.GetSpecificDocument<XGuildMineEntranceDocument>(XGuildMineEntranceDocument.uuID);

+							specificDocument2.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						}

+					}

+					else

+					{

+						if (systemid == XSysDefine.XSys_CrossGVG)

+						{

+							XCrossGVGDocument specificDocument3 = XDocuments.GetSpecificDocument<XCrossGVGDocument>(XCrossGVGDocument.uuID);

+							specificDocument3.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						}

+						if (systemid == XSysDefine.XSys_Rank_WorldBoss)

+						{

+							XWorldBossDocument specificDocument4 = XDocuments.GetSpecificDocument<XWorldBossDocument>(XWorldBossDocument.uuID);

+							specificDocument4.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						}

+					}

+				}

+				else if (systemid <= XSysDefine.XSys_MulActivity_SkyArenaEnd)

+				{

+					switch (systemid)

+					{

+					case XSysDefine.XSys_Activity_CaptainPVP:

+					{

+						XCaptainPVPDocument specificDocument5 = XDocuments.GetSpecificDocument<XCaptainPVPDocument>(XCaptainPVPDocument.uuID);

+						specificDocument5.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					}

+					case XSysDefine.XSys_Activity_GoddessTrial:

+					case XSysDefine.XSys_Activity_TeamTowerSingle:

+						break;

+					case XSysDefine.XSys_BigMelee:

+					{

+						XBigMeleeEntranceDocument specificDocument6 = XDocuments.GetSpecificDocument<XBigMeleeEntranceDocument>(XBigMeleeEntranceDocument.uuID);

+						specificDocument6.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					}

+					case XSysDefine.XSys_BigMeleeEnd:

+					{

+						XBigMeleeEntranceDocument specificDocument7 = XDocuments.GetSpecificDocument<XBigMeleeEntranceDocument>(XBigMeleeEntranceDocument.uuID);

+						specificDocument7.SetMainInterfaceBtnStateEnd(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					}

+					case XSysDefine.XSys_Battlefield:

+						XBattleFieldEntranceDocument.Doc.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					default:

+						switch (systemid)

+						{

+						case XSysDefine.XSys_MulActivity_SkyArena:

+							XSkyArenaEntranceDocument.Doc.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						case XSysDefine.XSys_MulActivity_Race:

+							DlgBase<RaceEntranceView, RaceEntranceBehaviour>.singleton.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						case XSysDefine.XSys_MulActivity_WeekendParty:

+						{

+							XWeekendPartyDocument specificDocument8 = XDocuments.GetSpecificDocument<XWeekendPartyDocument>(XWeekendPartyDocument.uuID);

+							specificDocument8.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						}

+						case XSysDefine.XSys_MulActivity_SkyArenaEnd:

+							XSkyArenaEntranceDocument.Doc.SetMainInterfaceBtnStateEnd(data.state == HallIconState.HICONS_BEGIN);

+							return;

+						}

+						break;

+					}

+				}

+				else

+				{

+					if (systemid == XSysDefine.XSys_TeamLeague)

+					{

+						XFreeTeamVersusLeagueDocument specificDocument9 = XDocuments.GetSpecificDocument<XFreeTeamVersusLeagueDocument>(XFreeTeamVersusLeagueDocument.uuID);

+						specificDocument9.SetMainInterfaceBtnState(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					}

+					if (systemid == XSysDefine.XSys_GuildMineEnd)

+					{

+						XGuildMineEntranceDocument specificDocument10 = XDocuments.GetSpecificDocument<XGuildMineEntranceDocument>(XGuildMineEntranceDocument.uuID);

+						specificDocument10.SetMainInterfaceBtnStateEnd(data.state == HallIconState.HICONS_BEGIN);

+						return;

+					}

+					if (systemid == XSysDefine.XSys_GuildCollect)

+					{

+						XGuildCollectDocument specificDocument11 = XDocuments.GetSpecificDocument<XGuildCollectDocument>(XGuildCollectDocument.uuID);

+						bool flag2 = data.state == HallIconState.HICONS_BEGIN;

+						specificDocument11.SetMainInterfaceBtnState(flag2 && XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_GUILD_HALL);

+						return;

+					}

+				}

+				XSingleton<XDebug>.singleton.AddErrorLog("Undefine system id from HallIconNtf. system = ", ((XSysDefine)data.systemid).ToString(), null, null, null, null);

+			}

+		}

+

+		protected override void OnReconnected(XReconnectedEventArgs arg)

+		{

+		}

+	}

+}