using System;
using System.Collections.Generic;
using KKSG;
using UILib;
using UnityEngine;
using XMainClient.UI.UICommon;
using XUpdater;
using XUtliPoolLib;

namespace XMainClient.UI
{
	internal class BattleMain : DlgBase<BattleMain, BattleMainBehaviour>
	{
		public BattleSkillHandler SkillHandler
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_SkillHandler;
			}
		}

		public BattleIndicateHandler IndicateHandler
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_IndicateHandler;
			}
		}

		public XTeamMonitorHandler TeamMonitor
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_TeamMonitor;
			}
		}

		public XBattleEnemyInfoHandler EnemyInfoHandler
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_EnemyInfoHandler;
			}
		}

		public BattleTargetHandler BattleTargetHandler
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_BattleTargetHandler;
			}
		}

		public XBattleTeamTowerHandler TeamTowerHandler
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_TeamTowerHandler;
			}
		}

		public IXUILabel WarTimeLabel
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_WarTime;
			}
		}

		public IXUILabel LeftTimeLabel
		{
			get
			{
				return (base.uiBehaviour == null) ? null : base.uiBehaviour.m_LeftTime;
			}
		}

		public BattleDpsHandler DpsHandler
		{
			get
			{
				return this.m_DpsHandler;
			}
		}

		private float _strength_preseved_precent
		{
			get
			{
				bool flag = this._current_strength_preseved > this._total_strength_preseved;
				if (flag)
				{
					this._total_strength_preseved = this._current_strength_preseved;
				}
				return this._current_strength_preseved / this._total_strength_preseved;
			}
		}

		public override string fileName
		{
			get
			{
				return "Battle/BattleDlg";
			}
		}

		public override int layer
		{
			get
			{
				return 1;
			}
		}

		public override bool isMainUI
		{
			get
			{
				return true;
			}
		}

		public static uint _pool_size = 5u;

		private float NoticeTime = 0f;

		private static Color32 _hp_green = new Color32(110, 174, 0, byte.MaxValue);

		private static Color32 _hp_yellow = new Color32(196, 180, 32, byte.MaxValue);

		private static Color32 _hp_red = new Color32(196, 57, 18, byte.MaxValue);

		private static float _fYellow = 0f;

		private static float _fRed = 0f;

		private bool _can_auto_play = false;

		private Vector2 m_DragDistance = Vector2.zero;

		private bool m_CancelRecord = false;

		private bool m_IsRecording = false;

		private uint m_ChatLabelCd = 0u;

		public ProfressionTrialsHandler ProfTrialsHandler;

		public BattleShowInfoHandler m_BattleShowInfoHandler = null;

		private BattleCaptainPVPHandler m_BattleCaptainPVPHandler = null;

		private GuildMinePVPBattleHandler m_GuildMinePVPBattleHandler = null;

		private GuildMinePVPInfoHandler m_GuildMinePVPInfoHandler = null;

		private SkyArenaBattleHandler m_SkyArenaBattleHandler = null;

		private SkyArenaInfoHandler m_SkyArenaInfoHandler = null;

		private AbyssPartyBattleHandler m_AbyssPartyBattleHandler = null;

		public BigMeleeBattleHandler m_BigMeleeBattleHandler = null;

		public BattleFieldBattleHandler m_BattleFieldBattleHandler = null;

		private XOptionsBattleHandler m_XOptionBattleHandler = null;

		private RaceBattleHandler m_RaceBattleHandler = null;

		public GuildMiniReportHandler m_miniReportHandler = null;

		public BattleRiftHandler m_riftHandler = null;

		public GuildBattleMiniRankHandler m_miniRankHandler = null;

		public HeroBattleSkillHandler m_HeroBattleSkillHandler = null;

		public HeroBattleHandler m_HeroBattleHandler = null;

		public MobaBattleHandler m_MobaBattleHandler = null;

		public WeekendPartyHandler m_WeekendPartyHandler = null;

		public BattleStatisticsHandler m_BattleStatisticsHandler = null;

		private BattleDpsHandler m_DpsHandler = null;

		private SceneType sceneType;

		private XLeftTimeCounter leftTimeCounter;

		public XLeftTimeCounter timeConnter;

		private List<string> _notice_collection = new List<string>();

		private float _notice_duration = 0f;

		private float _notice_pertime = 1f;

		private List<ComboBuff> _combo_buff_list = new List<ComboBuff>();

		private int _combo_buff_to_add = -1;

		private int _combo_buff_added = -1;

		private XBattleDocument _doc;

		private XApolloDocument apolloDoc;

		private uint time_token = 0u;

		public bool SpectateInfoIsShow;

		private XEntity _strength_preseved_entity = null;

		private float _total_strength_preseved = 1f;

		private float _current_strength_preseved = 0f;

		private float _last_check_time = 0f;

		private XTimerMgr.ElapsedEventHandler _showSingleNoticeCb = null;

		private XTimerMgr.ElapsedEventHandler _endBigNoticeCb = null;

		private XTimerMgr.ElapsedEventHandler _endBigNoticeCmdCb = null;

		private XTimerMgr.ElapsedEventHandler _onSwitchToTeamChatCb = null;

		private XTimerMgr.ElapsedEventHandler _hideBattleChatUICb = null;

		private XSwitchSight m_SwitchSight;

		private int _maxHP = 0;

		private int _currentHP = 0;

		private int _maxMP = 0;

		private int _currentMP = 0;

		public XYuyinView _yuyinHandler;

		private int type;

		private float lastPingTime = -60f;

		private float lastDebugUITrigger = -1f;

		private GameObject _big_notice = null;

		private uint _big_notice_timer_token = 0u;

		public BattleMain()
		{
			this._showSingleNoticeCb = new XTimerMgr.ElapsedEventHandler(this.ShowSingleNotice);
			this._endBigNoticeCb = new XTimerMgr.ElapsedEventHandler(this.EndBigNotice);
			this._endBigNoticeCmdCb = new XTimerMgr.ElapsedEventHandler(this.EndBigNoticeCmd);
			this._onSwitchToTeamChatCb = new XTimerMgr.ElapsedEventHandler(this.OnSwitchToTeamChat);
			this._hideBattleChatUICb = new XTimerMgr.ElapsedEventHandler(this.HideBattleChatUI);
			BattleMain._fYellow = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("HP_Yellow"));
			BattleMain._fRed = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("HP_Red"));
		}

		protected override void Init()
		{
			this._doc = XDocuments.GetSpecificDocument<XBattleDocument>(XBattleDocument.uuID);
			this.apolloDoc = XDocuments.GetSpecificDocument<XApolloDocument>(XApolloDocument.uuID);
			this._doc.BattleMainView = this;
			bool flag = XSingleton<XEntityMgr>.singleton.Player != null && XSingleton<XEntityMgr>.singleton.Player.Attributes != null;
			if (flag)
			{
				this._doc.FakeTeamAdd(XSingleton<XEntityMgr>.singleton.Player);
			}
			this.leftTimeCounter = new XLeftTimeCounter(base.uiBehaviour.m_LeftTime, true);
			this.timeConnter = new XLeftTimeCounter(base.uiBehaviour.m_WarTime, false);
			bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_MOBA || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HORSE_RACE || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_HORSERACING;
			if (flag2)
			{
				(base.uiBehaviour.m_PingFrame.GetComponent("PositionGroup") as IXPositionGroup).SetGroup(1);
				base.uiBehaviour.m_RoleInfo.gameObject.SetActive(false);
			}
			string value = XSingleton<XGlobalConfig>.singleton.GetValue("ComboBuff");
			string[] array = value.Split(XGlobalConfig.AllSeparators);
			for (int i = 0; i < array.Length; i += 3)
			{
				ComboBuff comboBuff = new ComboBuff();
				comboBuff.combo = int.Parse(array[i]);
				comboBuff.buffID = int.Parse(array[i + 1]);
				comboBuff.buffLevel = int.Parse(array[i + 2]);
				BuffTable.RowData buffData = XSingleton<XBuffTemplateManager>.singleton.GetBuffData(comboBuff.buffID, comboBuff.buffLevel);
				bool flag3 = buffData != null;
				if (flag3)
				{
					comboBuff.buffName = buffData.BuffName;
				}
				else
				{
					XSingleton<XDebug>.singleton.AddErrorLog(string.Format("ComboBuff: Buff data not found: [{0} {1}]", comboBuff.buffID, comboBuff.buffLevel), null, null, null, null, null);
				}
				this._combo_buff_list.Add(comboBuff);
			}
			this.SetupHandler();
		}

		private void SetupHandler()
		{
			SceneType sceneType = XSingleton<XScene>.singleton.SceneType;
			if (sceneType <= SceneType.SCENE_WEEKEND4V4_DUCK)
			{
				if (sceneType != SceneType.SCENE_PVP)
				{
					switch (sceneType)
					{
					case SceneType.SKYCITY_FIGHTING:
						DlgHandlerBase.EnsureCreate<SkyArenaBattleHandler>(ref this.m_SkyArenaBattleHandler, base.uiBehaviour.m_canvas, true, this);
						DlgHandlerBase.EnsureCreate<SkyArenaInfoHandler>(ref this.m_SkyArenaInfoHandler, base.uiBehaviour.m_canvas, true, null);
						break;
					case SceneType.SCENE_PROF_TRIALS:
						DlgHandlerBase.EnsureCreate<ProfressionTrialsHandler>(ref this.ProfTrialsHandler, base.uiBehaviour.m_canvas, true, this);
						break;
					case SceneType.SCENE_GPR:
						break;
					case SceneType.SCENE_RESWAR_PVP:
						DlgHandlerBase.EnsureCreate<GuildMinePVPBattleHandler>(ref this.m_GuildMinePVPBattleHandler, base.uiBehaviour.m_canvas, true, null);
						DlgHandlerBase.EnsureCreate<GuildMinePVPInfoHandler>(ref this.m_GuildMinePVPInfoHandler, base.uiBehaviour.m_canvas, true, null);
						break;
					default:
						switch (sceneType)
						{
						case SceneType.SCENE_HORSE_RACE:
						case SceneType.SCENE_WEEKEND4V4_HORSERACING:
							DlgHandlerBase.EnsureCreate<RaceBattleHandler>(ref this.m_RaceBattleHandler, base.uiBehaviour.m_canvas, true, this);
							DlgHandlerBase.EnsureCreate<BattleShowInfoHandler>(ref this.m_BattleShowInfoHandler, base.uiBehaviour.m_canvas, true, this);
							break;
						case SceneType.SCENE_HEROBATTLE:
							DlgHandlerBase.EnsureCreate<HeroBattleSkillHandler>(ref this.m_HeroBattleSkillHandler, base.uiBehaviour.m_canvas, true, this);
							DlgHandlerBase.EnsureCreate<HeroBattleHandler>(ref this.m_HeroBattleHandler, base.uiBehaviour.m_canvas, true, this);
							this.m_HeroBattleSkillHandler.HandlerType = 0;
							break;
						case SceneType.SCENE_CASTLE_WAIT:
						case SceneType.SCENE_CASTLE_FIGHT:
							DlgHandlerBase.EnsureCreate<GuildBattleMiniRankHandler>(ref this.m_miniRankHandler, base.uiBehaviour.m_canvas, true, this);
							DlgHandlerBase.EnsureCreate<GuildMiniReportHandler>(ref this.m_miniReportHandler, base.uiBehaviour.m_canvas, true, this);
							break;
						case SceneType.SCENE_ABYSS_PARTY:
							DlgHandlerBase.EnsureCreate<AbyssPartyBattleHandler>(ref this.m_AbyssPartyBattleHandler, base.uiBehaviour.m_canvas, true, null);
							break;
						case SceneType.SCENE_MOBA:
							DlgHandlerBase.EnsureCreate<HeroBattleSkillHandler>(ref this.m_HeroBattleSkillHandler, base.uiBehaviour.m_canvas, true, this);
							DlgHandlerBase.EnsureCreate<MobaBattleHandler>(ref this.m_MobaBattleHandler, base.uiBehaviour.m_canvas, true, this);
							this.m_HeroBattleSkillHandler.HandlerType = 2;
							break;
						case SceneType.SCENE_WEEKEND4V4_MONSTERFIGHT:
						case SceneType.SCENE_WEEKEND4V4_GHOSTACTION:
						case SceneType.SCENE_WEEKEND4V4_LIVECHALLENGE:
						case SceneType.SCENE_WEEKEND4V4_CRAZYBOMB:
						case SceneType.SCENE_WEEKEND4V4_DUCK:
							DlgHandlerBase.EnsureCreate<WeekendPartyHandler>(ref this.m_WeekendPartyHandler, base.uiBehaviour.m_canvas, true, this);
							break;
						}
						break;
					}
				}
				else
				{
					DlgHandlerBase.EnsureCreate<BattleCaptainPVPHandler>(ref this.m_BattleCaptainPVPHandler, base.uiBehaviour.m_canvas, true, this);
				}
			}
			else if (sceneType != SceneType.SCENE_BIGMELEE_FIGHT)
			{
				if (sceneType != SceneType.SCENE_BATTLEFIELD_FIGHT)
				{
					if (sceneType == SceneType.SCENE_RIFT)
					{
						DlgHandlerBase.EnsureCreate<BattleRiftHandler>(ref this.m_riftHandler, base.uiBehaviour.m_canvas, true, this);
					}
				}
				else
				{
					DlgHandlerBase.EnsureCreate<BattleFieldBattleHandler>(ref this.m_BattleFieldBattleHandler, base.uiBehaviour.m_canvas, true, this);
				}
			}
			else
			{
				DlgHandlerBase.EnsureCreate<BigMeleeBattleHandler>(ref this.m_BigMeleeBattleHandler, base.uiBehaviour.m_canvas, true, this);
			}
			bool loadSkillHandler = XHeroBattleDocument.LoadSkillHandler;
			if (loadSkillHandler)
			{
				DlgHandlerBase.EnsureCreate<HeroBattleSkillHandler>(ref this.m_HeroBattleSkillHandler, base.uiBehaviour.m_canvas, true, this);
				this.m_HeroBattleSkillHandler.HandlerType = 1;
			}
		}

		public override void RegisterEvent()
		{
			base.uiBehaviour.m_avatar.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnAvatarClick));
			base.uiBehaviour.m_pause.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnPauseClick));
			base.uiBehaviour.m_AutoPlay.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnAutoPlay));
			base.uiBehaviour.m_CancelAuto.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnAutoPlay));
			base.uiBehaviour.m_AutoPlayTip.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnAutoPlayTip));
			base.uiBehaviour.m_HorseRide.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnHorseRideClicked));
			this.m_SwitchSight = new XSwitchSight(new ButtonClickEventHandler(this.OnSightSelectClick), base.uiBehaviour.m_25D, base.uiBehaviour.m_3D, base.uiBehaviour.m_3DFree);
			base.uiBehaviour.m_BtnDamageStatistics.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnBattleStatisticsClick));
			base.uiBehaviour.m_Sight.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnSightClick));
		}

		protected override void OnShow()
		{
			base.OnShow();
			XPlayerAttributes xplayerAttributes = XSingleton<XEntityMgr>.singleton.Player.Attributes as XPlayerAttributes;
			base.uiBehaviour.m_SightSelect.gameObject.SetActive(false);
			DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.Show(true);
			DlgBase<RadioBattleDlg, RadioBattleBahaviour>.singleton.Show(true);
			base.uiBehaviour.m_objBossRush.SetActive(XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_BOSSRUSH);
			this.lastPingTime = -60f;
			this._combo_buff_to_add = -1;
			this._combo_buff_added = -1;
			int profID = XFastEnumIntEqualityComparer<RoleType>.ToInt(XSingleton<XEntityMgr>.singleton.Player.PlayerAttributes.Profession);
			base.uiBehaviour.m_avatar.spriteName = XSingleton<XProfessionSkillMgr>.singleton.GetProfHeadIcon(profID);
			this.SetTencentImage();
			base.uiBehaviour.m_Level.SetText(string.Format("{0}", XSingleton<XAttributeMgr>.singleton.XPlayerData.Level));
			base.uiBehaviour.m_Name.SetText(XSingleton<XEntityMgr>.singleton.Player.Name);
			XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
			this.SpectateInfoIsShow = false;
			XSpectateSceneDocument specificDocument2 = XDocuments.GetSpecificDocument<XSpectateSceneDocument>(XSpectateSceneDocument.uuID);
			base.uiBehaviour.m_SpectateInfo.transform.localPosition = Vector3.one * (float)XGameUI._far_far_away;
			specificDocument2.GetTargetNum(true);
			this.OnSpectateMessageChange(0, 0);
			base.uiBehaviour.m_TeamLeader.SetActive(specificDocument.bIsLeader);
			base.uiBehaviour.m_AutoPlayBorad.SetVisible(false);
			base.uiBehaviour.m_AutoPlayCancelBoard.SetVisible(false);
			base.uiBehaviour.m_SkillHandler.SetVisible(true);
			base.uiBehaviour.m_IndicateHandler.SetVisible(true);
			base.uiBehaviour.m_lblKill.SetVisible(false);
			base.uiBehaviour.m_SceneName.SetText(XSingleton<XScene>.singleton.SceneData.Comment);
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData.TimeCounter == null || sceneData.TimeCounter.Length < 1;
			if (flag)
			{
				this.SetTimeRecord();
			}
			else
			{
				bool flag2 = sceneData.TimeCounter[0] == 1;
				if (flag2)
				{
					bool flag3 = sceneData.TimeCounter.Length > 2;
					if (flag3)
					{
						this.SetLeftTime((uint)sceneData.TimeCounter[1], (int)sceneData.TimeCounter[2]);
					}
					else
					{
						this.SetLeftTime((uint)sceneData.TimeCounter[1], -1);
					}
				}
			}
			XCombatStatisticsDocument specificDocument3 = XDocuments.GetSpecificDocument<XCombatStatisticsDocument>(XCombatStatisticsDocument.uuID);
			DlgHandlerBase.EnsureCreate<BattleDpsHandler>(ref this.m_DpsHandler, base.uiBehaviour.m_DpsPanel, this, specificDocument3.bShowDps);
			bool visible = false;
			SeqListRef<int> winCondition = sceneData.WinCondition;
			for (int i = 0; i < winCondition.Count; i++)
			{
				bool flag4 = winCondition[i, 0] == 8;
				if (flag4)
				{
					visible = true;
				}
			}
			base.uiBehaviour.m_lblKill.SetVisible(visible);
			this.UpdateKill(0);
			this.sceneType = (SceneType)sceneData.type;
			SceneType sceneType = this.sceneType;
			if (sceneType <= SceneType.SCENE_TOWER)
			{
				if (sceneType != SceneType.SCENE_BATTLE)
				{
					switch (sceneType)
					{
					case SceneType.SCENE_WORLDBOSS:
					case SceneType.SCENE_GUILD_BOSS:
						base.uiBehaviour.m_WorldBossHandler.SetVisible(true);
						break;
					case (SceneType)8:
					case SceneType.SCENE_BOSSRUSH:
					case SceneType.SCENE_GUILD_HALL:
						break;
					case SceneType.SCENE_PK:
					{
						XQualifyingDocument specificDocument4 = XDocuments.GetSpecificDocument<XQualifyingDocument>(XQualifyingDocument.uuID);
						bool flag5 = specificDocument4.PkInfoList.Count > 0;
						if (flag5)
						{
							this.SetEnemyRoleInfo(specificDocument4.PkInfoList[0].brief.roleName, specificDocument4.PkInfoList[0].brief.roleLevel);
						}
						break;
					}
					case SceneType.SCENE_ABYSSS:
						break;
					default:
						if (sceneType == SceneType.SCENE_TOWER)
						{
							base.uiBehaviour.m_TeamTowerHandler.SetVisible(true);
						}
						break;
					}
				}
			}
			else if (sceneType <= SceneType.SCENE_GUILD_CAMP)
			{
				switch (sceneType)
				{
				case SceneType.SCENE_GODDESS:
				case SceneType.SCENE_ENDLESSABYSS:
					this.GetTeamLeftTimes();
					break;
				case SceneType.SCENE_DRAGON_EXP:
					break;
				case SceneType.SCENE_RISK:
					break;
				default:
					if (sceneType != SceneType.SCENE_GUILD_CAMP)
					{
					}
					break;
				}
			}
			else if (sceneType != SceneType.SCENE_INVFIGHT)
			{
				if (sceneType == SceneType.SCENE_CASTLE_WAIT)
				{
					base.uiBehaviour.m_SkillHandler.SetVisible(false);
				}
			}
			else
			{
				XPKInvitationDocument specificDocument5 = XDocuments.GetSpecificDocument<XPKInvitationDocument>(XPKInvitationDocument.uuID);
				bool flag6 = specificDocument5.PKInfoList.Count > 0;
				if (flag6)
				{
					this.SetEnemyRoleInfo(specificDocument5.PKInfoList[0].roleName, specificDocument5.PKInfoList[0].roleLevel);
				}
			}
			this.SetWinConditionTips();
			this.SetBattleExplainTips();
			XPlayerAttributes xplayerAttributes2 = XSingleton<XEntityMgr>.singleton.Player.Attributes as XPlayerAttributes;
			bool flag7 = XSingleton<XSceneMgr>.singleton.CanAutoPlay(XSingleton<XScene>.singleton.SceneID);
			bool flag8 = XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < uint.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("AutoPlayUnlockLevel"));
			base.uiBehaviour.m_AutoPlayContent.SetActive(flag7);
			bool flag9 = flag7;
			if (flag9)
			{
				this._can_auto_play = true;
				bool flag10 = flag8;
				if (flag10)
				{
					base.uiBehaviour.m_AutoPlayBorad.SetVisible(true);
					base.uiBehaviour.m_AutoPlay.SetEnable(false, false);
					base.uiBehaviour.m_AutoPlayLock.SetVisible(true);
				}
				else
				{
					bool flag11 = this.sceneType == SceneType.SCENE_GODDESS;
					if (flag11)
					{
						base.uiBehaviour.m_AutoPlayCancelBoard.SetVisible(true);
					}
					else
					{
						bool autoPlayOn = xplayerAttributes2.AutoPlayOn;
						if (autoPlayOn)
						{
							base.uiBehaviour.m_AutoPlayCancelBoard.SetVisible(true);
						}
						else
						{
							base.uiBehaviour.m_AutoPlayBorad.SetVisible(true);
						}
					}
					base.uiBehaviour.m_AutoPlayLock.SetVisible(false);
					base.uiBehaviour.m_AutoPlay.SetEnable(true, false);
				}
			}
			else
			{
				this._can_auto_play = false;
				xplayerAttributes2.AutoPlayOn = false;
			}
			SceneType sceneType2 = this.sceneType;
			if (sceneType2 != SceneType.SCENE_ARENA && sceneType2 != SceneType.SCENE_PK && sceneType2 != SceneType.SCENE_INVFIGHT)
			{
				this.EnemyInfoHandler.InitBoss();
			}
			else
			{
				this.EnemyInfoHandler.InitRole();
			}
			XTeamDocument specificDocument6 = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
			bool flag12 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_PVP;
			if (flag12)
			{
				XBattleCaptainPVPDocument specificDocument7 = XDocuments.GetSpecificDocument<XBattleCaptainPVPDocument>(XBattleCaptainPVPDocument.uuID);
				this.TeamMonitor.InitWhenShowMainUIByBloodList(specificDocument7.TeamBlood);
			}
			else
			{
				bool flag13 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_HEROBATTLE;
				if (flag13)
				{
					XHeroBattleDocument specificDocument8 = XDocuments.GetSpecificDocument<XHeroBattleDocument>(XHeroBattleDocument.uuID);
					this.TeamMonitor.InitWhenShowMainUIByBloodList(specificDocument8.TeamBlood);
				}
				else
				{
					bool flag14 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_CRAZYBOMB || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_GHOSTACTION || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_HORSERACING || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_LIVECHALLENGE || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_MONSTERFIGHT || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_WEEKEND4V4_DUCK;
					if (flag14)
					{
						XWeekendPartyDocument specificDocument9 = XDocuments.GetSpecificDocument<XWeekendPartyDocument>(XWeekendPartyDocument.uuID);
						this.TeamMonitor.InitWhenShowMainUIByBloodList(specificDocument9.TeamBlood);
					}
					else
					{
						this.TeamMonitor.InitWhenShowMainUIByTeam(specificDocument6.MyTeam);
					}
				}
			}
			bool flag15 = XSingleton<XScene>.singleton.SceneID != 100u && XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_CALLBACK && (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("ShowChatLevelBattle")));
			if (flag15)
			{
				ShowSettingArgs showSettingArgs = new ShowSettingArgs();
				showSettingArgs.position = 2;
				showSettingArgs.showsettings = false;
				showSettingArgs.enablebackclick = true;
				showSettingArgs.enabledrag = false;
				DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.ShowChatMiniUI(showSettingArgs);
			}
			base.uiBehaviour.m_StrengthPresevedBar.SetVisible(this._doc.ShowStrengthPresevedBar);
			this.RefreshYuyin();
			this.InitView();
			bool flag16 = this.apolloDoc != null;
			if (flag16)
			{
				this.apolloDoc.RequestJoinRoom();
			}
			bool flag17 = XSingleton<XScene>.singleton.SceneType == SceneType.SKYCITY_FIGHTING || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_BIGMELEE_FIGHT;
			if (flag17)
			{
				base.uiBehaviour.m_SkyAreanStage.gameObject.SetActive(true);
			}
			else
			{
				base.uiBehaviour.m_SkyAreanStage.gameObject.SetActive(false);
			}
			bool flag18 = (ulong)XSingleton<XScene>.singleton.SceneID == (ulong)((long)int.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("GuildCampHorseSceneID")));
			if (flag18)
			{
				base.uiBehaviour.m_HorseRide.gameObject.SetActive(true);
			}
			else
			{
				base.uiBehaviour.m_HorseRide.gameObject.SetActive(false);
			}
			base.uiBehaviour.m_GuildMineBuff.gameObject.SetActive(false);
			base.uiBehaviour.m_pauseGroup.SetGroup((XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_MOBA) ? 1 : 0);
			base.uiBehaviour.m_3D25D.gameObject.SetActive(XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_MOBA);
			base.uiBehaviour.m_BtnDamageStatistics.SetVisible(sceneData.ShowBattleStatistics);
			base.uiBehaviour.m_Menu.Refresh();
		}

		private void InitView()
		{
			this.SetView(XSingleton<XOperationData>.singleton.OperationMode);
		}

		public void SetView(XOperationMode mode)
		{
			bool flag = base.uiBehaviour == null || base.uiBehaviour.m_SightPic == null || base.uiBehaviour.m_SelectPic == null || base.uiBehaviour.m_SightSelect == null;
			if (!flag)
			{
				switch (mode)
				{
				case XOperationMode.X25D:
					base.uiBehaviour.m_SightPic.SetSprite("l_zdicon_1_1");
					base.uiBehaviour.m_SelectPic.SetSprite("l_zdicon_1_1");
					break;
				case XOperationMode.X3D:
					base.uiBehaviour.m_SightPic.SetSprite("l_zdicon_1_0");
					base.uiBehaviour.m_SelectPic.SetSprite("l_zdicon_1_0");
					break;
				case XOperationMode.X3D_Free:
					base.uiBehaviour.m_SightPic.SetSprite("l_zdicon_1_2");
					base.uiBehaviour.m_SelectPic.SetSprite("l_zdicon_1_2");
					break;
				}
				base.uiBehaviour.m_SightPic.MakePixelPerfect();
				base.uiBehaviour.m_SelectPic.MakePixelPerfect();
				base.uiBehaviour.m_SightSelect.gameObject.SetActive(false);
			}
		}

		private void SetStartAutoPlay()
		{
			this.SetAutoPlay(true);
		}

		private void GetTeamLeftTimes()
		{
			XTeamDocument specificDocument = XDocuments.GetSpecificDocument<XTeamDocument>(XTeamDocument.uuID);
			specificDocument.ReqTeamOp(TeamOperate.TEAM_QUERYCOUNT, 0UL, null, TeamMemberType.TMT_NORMAL, null);
		}

		private void SetWinConditionTips()
		{
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData == null || string.IsNullOrEmpty(sceneData.WinConditionTips);
			if (flag)
			{
				base.uiBehaviour.m_winConditionTips.SetVisible(false);
			}
			else
			{
				base.uiBehaviour.m_winConditionTips.SetVisible(true);
				string text = sceneData.WinConditionTips.Replace("/n", "\n");
				base.uiBehaviour.m_winConditionTips.SetText(text);
			}
		}

		private void SetBattleExplainTips()
		{
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData == null || string.IsNullOrEmpty(sceneData.BattleExplainTips);
			if (flag)
			{
				base.uiBehaviour.m_BattleExplainTips.SetVisible(false);
			}
			else
			{
				base.uiBehaviour.m_BattleExplainTips.SetVisible(true);
				string text = XSingleton<UiUtility>.singleton.ReplaceReturn(sceneData.BattleExplainTips);
				base.uiBehaviour.m_BattleExplainTips.SetText(text);
			}
		}

		public void SetTeamLeftTimes()
		{
			base.uiBehaviour.m_leftTimes.SetVisible(true);
			XExpeditionDocument specificDocument = XDocuments.GetSpecificDocument<XExpeditionDocument>(XExpeditionDocument.uuID);
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData.type == 20;
			if (flag)
			{
				int dayCount = specificDocument.GetDayCount(TeamLevelType.TeamLevelGoddessTrial, null);
				int dayMaxCount = specificDocument.GetDayMaxCount(TeamLevelType.TeamLevelGoddessTrial, null);
				base.uiBehaviour.m_leftTimes.SetText(string.Format("{0}({1}/{2})", XStringDefineProxy.GetString("GODDESS_NAME"), dayMaxCount - dayCount, dayMaxCount));
			}
			else
			{
				bool flag2 = sceneData.type == 23;
				if (flag2)
				{
					int dayCount = specificDocument.GetDayCount(TeamLevelType.TeamLevelEndlessAbyss, null);
					int dayMaxCount = specificDocument.GetDayMaxCount(TeamLevelType.TeamLevelEndlessAbyss, null);
					base.uiBehaviour.m_leftTimes.SetText(string.Format("{0}({1}/{2})", XStringDefineProxy.GetString("EndlessAbyss"), dayMaxCount - dayCount, dayMaxCount));
				}
				else
				{
					base.uiBehaviour.m_leftTimes.SetVisible(false);
				}
			}
		}

		protected override void OnLoad()
		{
			this._maxHP = 0;
			this._currentHP = 0;
			this._maxMP = 0;
			this._currentMP = 0;
			base.OnLoad();
			DlgHandlerBase.EnsureCreate<XYuyinView>(ref this._yuyinHandler, base.uiBehaviour.transform, true, this);
		}

		protected override void OnHide()
		{
			base.uiBehaviour.m_SkillHandler.SetVisible(false);
			bool flag = DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.IsLoaded();
			if (flag)
			{
				DlgBase<XChatSmallView, XChatSmallBehaviour>.singleton.SetVisible(false, true);
			}
			bool flag2 = DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.IsLoaded();
			if (flag2)
			{
				DlgBase<BroadMiniDlg, BroadcastMiniBehaviour>.singleton.Show(false);
			}
			bool flag3 = DlgBase<RadioBattleDlg, RadioBattleBahaviour>.singleton.IsLoaded();
			if (flag3)
			{
				DlgBase<RadioBattleDlg, RadioBattleBahaviour>.singleton.Show(false);
			}
			bool flag4 = DlgBase<XChatView, XChatBehaviour>.singleton.IsLoaded();
			if (flag4)
			{
				DlgBase<XChatView, XChatBehaviour>.singleton.SetVisible(false, true);
			}
			this._maxHP = 0;
			this._currentHP = 0;
			this._maxMP = 0;
			this._currentMP = 0;
			base.OnHide();
		}

		protected override void OnUnload()
		{
			this.m_uiBehaviour.m_txtHead.SetTexturePath("");
			DlgHandlerBase.EnsureUnload<BattleShowInfoHandler>(ref this.m_BattleShowInfoHandler);
			DlgHandlerBase.EnsureUnload<BattleCaptainPVPHandler>(ref this.m_BattleCaptainPVPHandler);
			DlgHandlerBase.EnsureUnload<GuildMinePVPBattleHandler>(ref this.m_GuildMinePVPBattleHandler);
			DlgHandlerBase.EnsureUnload<GuildMinePVPInfoHandler>(ref this.m_GuildMinePVPInfoHandler);
			DlgHandlerBase.EnsureUnload<SkyArenaBattleHandler>(ref this.m_SkyArenaBattleHandler);
			DlgHandlerBase.EnsureUnload<SkyArenaInfoHandler>(ref this.m_SkyArenaInfoHandler);
			DlgHandlerBase.EnsureUnload<AbyssPartyBattleHandler>(ref this.m_AbyssPartyBattleHandler);
			DlgHandlerBase.EnsureUnload<BigMeleeBattleHandler>(ref this.m_BigMeleeBattleHandler);
			DlgHandlerBase.EnsureUnload<BattleFieldBattleHandler>(ref this.m_BattleFieldBattleHandler);
			DlgHandlerBase.EnsureUnload<XOptionsBattleHandler>(ref this.m_XOptionBattleHandler);
			DlgHandlerBase.EnsureUnload<RaceBattleHandler>(ref this.m_RaceBattleHandler);
			DlgHandlerBase.EnsureUnload<BattleWorldBossHandler>(ref base.uiBehaviour.m_WorldBossHandler);
			DlgHandlerBase.EnsureUnload<BattleSkillHandler>(ref base.uiBehaviour.m_SkillHandler);
			DlgHandlerBase.EnsureUnload<BattleIndicateHandler>(ref base.uiBehaviour.m_IndicateHandler);
			DlgHandlerBase.EnsureUnload<XTeamMonitorHandler>(ref base.uiBehaviour.m_TeamMonitor);
			DlgHandlerBase.EnsureUnload<XBattleEnemyInfoHandler>(ref base.uiBehaviour.m_EnemyInfoHandler);
			DlgHandlerBase.EnsureUnload<XBuffMonitorHandler>(ref base.uiBehaviour.m_PlayerBuffMonitorHandler);
			DlgHandlerBase.EnsureUnload<ProfressionTrialsHandler>(ref this.ProfTrialsHandler);
			DlgHandlerBase.EnsureUnload<BattleDpsHandler>(ref this.m_DpsHandler);
			DlgHandlerBase.EnsureUnload<XYuyinView>(ref this._yuyinHandler);
			DlgHandlerBase.EnsureUnload<HeroBattleSkillHandler>(ref this.m_HeroBattleSkillHandler);
			DlgHandlerBase.EnsureUnload<HeroBattleHandler>(ref this.m_HeroBattleHandler);
			DlgHandlerBase.EnsureUnload<MobaBattleHandler>(ref this.m_MobaBattleHandler);
			DlgHandlerBase.EnsureUnload<GuildMiniReportHandler>(ref this.m_miniReportHandler);
			DlgHandlerBase.EnsureUnload<GuildBattleMiniRankHandler>(ref this.m_miniRankHandler);
			DlgHandlerBase.EnsureUnload<BattleRiftHandler>(ref this.m_riftHandler);
			DlgHandlerBase.EnsureUnload<WeekendPartyHandler>(ref this.m_WeekendPartyHandler);
			DlgHandlerBase.EnsureUnload<BattleStatisticsHandler>(ref this.m_BattleStatisticsHandler);
			this._doc.BattleMainView = null;
			bool flag = this.apolloDoc != null;
			if (flag)
			{
				this.apolloDoc.QuitRoom();
			}
			this.ClearBigNotice();
			base.OnUnload();
		}

		private void RefreshYuyin()
		{
			this.type = XFastEnumIntEqualityComparer<SceneType>.ToInt(XSingleton<XScene>.singleton.SceneType);
			bool flag = this._yuyinHandler != null;
			if (flag)
			{
				this._yuyinHandler.Refresh(this.type);
			}
		}

		public void RefreshYuyin(ulong uid)
		{
			bool flag = this._yuyinHandler != null;
			if (flag)
			{
				this._yuyinHandler.Refresh(this.type);
			}
		}

		private void SetEnemyRoleInfo(string name, uint level)
		{
		}

		private bool OnTailToBackClick(IXUIButton go)
		{
			XSingleton<XScene>.singleton.GameCamera.Tail.TailToBack();
			return true;
		}

		private bool OnPauseClick(IXUIButton go)
		{
			bool flag = !base.IsLoaded();
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
				bool flag2 = sceneData != null;
				if (flag2)
				{
					bool canPause = sceneData.CanPause;
					if (canPause)
					{
						XSingleton<XShell>.singleton.Pause = true;
					}
				}
				bool flag3 = this.m_XOptionBattleHandler == null;
				if (flag3)
				{
					bool flag4 = base.uiBehaviour != null;
					if (flag4)
					{
						DlgHandlerBase.EnsureCreate<XOptionsBattleHandler>(ref this.m_XOptionBattleHandler, base.uiBehaviour.m_canvas, true, this);
					}
				}
				bool flag5 = this.m_XOptionBattleHandler != null && !this.m_XOptionBattleHandler.IsVisible();
				if (flag5)
				{
					this.m_XOptionBattleHandler.ShowUI();
				}
				this.sceneType = XSingleton<XScene>.singleton.SceneType;
				result = true;
			}
			return result;
		}

		private void OnAvatarClick(IXUISprite go)
		{
			bool flag = !base.IsLoaded();
			if (!flag)
			{
				bool flag2 = DlgBase<DemoUI, DemoUIBehaviour>.singleton.IsVisible();
				DlgBase<DemoUI, DemoUIBehaviour>.singleton.SetVisible(!flag2, true);
			}
		}

		public void SetTencentImage()
		{
			bool flag = XSingleton<PDatabase>.singleton.playerInfo != null;
			if (flag)
			{
				string pictureLarge = XSingleton<PDatabase>.singleton.playerInfo.data.pictureLarge;
				XSingleton<XUICacheImage>.singleton.Load(pictureLarge, this.m_uiBehaviour.m_txtHead, this.m_uiBehaviour);
			}
			else
			{
				XSingleton<XUICacheImage>.singleton.Load(string.Empty, this.m_uiBehaviour.m_txtHead, this.m_uiBehaviour);
			}
			XPrerogativeDocument specificDocument = XDocuments.GetSpecificDocument<XPrerogativeDocument>(XPrerogativeDocument.uuID);
			XSingleton<UiUtility>.singleton.ParseHeadIcon(specificDocument.PlayerSetid, base.uiBehaviour.m_sprFrame);
		}

		private bool OnBussrushPauseClick(IXUIButton btn)
		{
			XSingleton<XScene>.singleton.ReqLeaveScene();
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
			return true;
		}

		public void ShowBossrushQuit()
		{
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(true, true);
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
			string @string = XStringDefineProxy.GetString("BOSSRUSH_QUIT");
			string string2 = XStringDefineProxy.GetString("COMMON_OK");
			string string3 = XStringDefineProxy.GetString("COMMON_CANCEL");
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(@string, string2, string3);
			DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnBussrushPauseClick), null);
		}

		private void UpdatePlayerInfo()
		{
			XPlayerAttributes xplayerData = XSingleton<XAttributeMgr>.singleton.XPlayerData;
			bool flag = xplayerData != null;
			if (flag)
			{
				int num = (int)xplayerData.GetAttr(XAttributeDefine.XAttr_MaxHP_Total);
				int num2 = (int)xplayerData.GetAttr(XAttributeDefine.XAttr_CurrentHP_Basic);
				int num3 = (int)xplayerData.GetAttr(XAttributeDefine.XAttr_MaxMP_Total);
				int num4 = (int)xplayerData.GetAttr(XAttributeDefine.XAttr_CurrentMP_Basic);
				bool flag2 = num2 < 0;
				if (flag2)
				{
					num2 = 0;
				}
				float num5 = (float)num2 / (float)num;
				base.uiBehaviour.m_Hpbar.SetFillAmount(num5);
				float fillAmount = (float)num4 / (float)num3;
				base.uiBehaviour.m_Mpbar.SetFillAmount(fillAmount);
				bool flag3 = this._currentHP != num2 || this._maxHP != num;
				if (flag3)
				{
					base.uiBehaviour.m_HpText.SetText(string.Format("{0}/{1}", num2, num));
					this._currentHP = num2;
					this._maxHP = num;
				}
				bool flag4 = this._currentMP != num4 || this._maxMP != num3;
				if (flag4)
				{
					base.uiBehaviour.m_MpText.SetText(string.Format("{0}/{1}", num4, num3));
					this._currentMP = num4;
					this._maxMP = num3;
				}
				Color color;
				bool active;
				BattleMain.GetHPColor(num5, out color, out active);
				base.uiBehaviour.m_LowHP.SetActive(active);
			}
		}

		public static void GetHPColor(float hpPercent, out Color color, out bool bLowHP)
		{
			bool flag = hpPercent > BattleMain._fYellow;
			if (flag)
			{
				color = BattleMain._hp_green;
				bLowHP = false;
			}
			else
			{
				bool flag2 = hpPercent <= BattleMain._fYellow && hpPercent > BattleMain._fRed;
				if (flag2)
				{
					color = BattleMain._hp_yellow;
					bLowHP = false;
				}
				else
				{
					color = BattleMain._hp_red;
					bLowHP = true;
				}
			}
		}

		public void OnPlayerBuffChange()
		{
			base.uiBehaviour.m_PlayerBuffMonitorHandler.OnBuffChanged(XSingleton<XEntityMgr>.singleton.Player.Buffs.GetUIBuffList());
		}

		public override void OnUpdate()
		{
			base.uiBehaviour.m_SkillHandler.OnUpdate();
			bool flag = !XSingleton<XTimerMgr>.singleton.NeedFixedUpdate;
			if (!flag)
			{
				base.OnUpdate();
				bool flag2 = this.lastDebugUITrigger > 0f;
				if (flag2)
				{
					this.lastDebugUITrigger -= Time.deltaTime;
				}
				bool flag3 = this.lastDebugUITrigger <= 0f && Input.GetKey((KeyCode)285);
				if (flag3)
				{
					DlgBase<DemoUI, DemoUIBehaviour>.singleton.Toggle();
					this.lastDebugUITrigger = 0.05f;
				}
				bool key = Input.GetKey((KeyCode)96);
				if (key)
				{
					bool flag4 = Input.GetKey((KeyCode)256) || Input.GetKey((KeyCode)48);
					if (flag4)
					{
						XSingleton<XCommand>.singleton.CustomCommand(0);
					}
					bool flag5 = Input.GetKey((KeyCode)257) || Input.GetKey((KeyCode)49);
					if (flag5)
					{
						XSingleton<XCommand>.singleton.CustomCommand(1);
					}
					bool flag6 = Input.GetKey((KeyCode)258) || Input.GetKey((KeyCode)50);
					if (flag6)
					{
						XSingleton<XCommand>.singleton.CustomCommand(2);
					}
					bool flag7 = Input.GetKey((KeyCode)259) || Input.GetKey((KeyCode)51);
					if (flag7)
					{
						XSingleton<XCommand>.singleton.CustomCommand(3);
					}
					bool flag8 = Input.GetKey((KeyCode)260) || Input.GetKey((KeyCode)52);
					if (flag8)
					{
						XSingleton<XCommand>.singleton.CustomCommand(4);
					}
					bool flag9 = Input.GetKey((KeyCode)261) || Input.GetKey((KeyCode)53);
					if (flag9)
					{
						XSingleton<XCommand>.singleton.CustomCommand(5);
					}
					bool flag10 = Input.GetKey((KeyCode)262) || Input.GetKey((KeyCode)54);
					if (flag10)
					{
						XSingleton<XCommand>.singleton.CustomCommand(6);
					}
					bool flag11 = Input.GetKey((KeyCode)263) || Input.GetKey((KeyCode)55);
					if (flag11)
					{
						XSingleton<XCommand>.singleton.CustomCommand(7);
					}
					bool flag12 = Input.GetKey((KeyCode)264) || Input.GetKey((KeyCode)56);
					if (flag12)
					{
						XSingleton<XCommand>.singleton.CustomCommand(8);
					}
					bool flag13 = Input.GetKey((KeyCode)265) || Input.GetKey((KeyCode)57);
					if (flag13)
					{
						XSingleton<XCommand>.singleton.CustomCommand(9);
					}
				}
				this.UpdatePlayerInfo();
				this.UpdateWifi();
				bool flag14 = Time.unscaledTime - this.lastPingTime > 60f || this.lastPingTime < 0f;
				if (flag14)
				{
					this.RefreshPing();
					this.lastPingTime = Time.unscaledTime;
				}
				base.uiBehaviour.m_IndicateHandler.OnUpdate();
				bool flag15 = Time.time - this._last_check_time > 5f;
				if (flag15)
				{
					this._last_check_time = Time.time;
					this._doc.SendCheckTime();
				}
				this.UpdateTime();
				this.UpdateLeftTime();
				bool flag16 = this.NoticeTime > 0f;
				if (flag16)
				{
					bool flag17 = Time.time - this.NoticeTime > this._notice_duration;
					if (flag17)
					{
						base.uiBehaviour.m_NoticeFrame.transform.localPosition = XGameUI.Far_Far_Away;
						this.NoticeTime = 0f;
					}
				}
				bool active = base.uiBehaviour.m_WorldBossHandler.active;
				if (active)
				{
					base.uiBehaviour.m_WorldBossHandler.OnUpdate();
				}
				IXGameSirControl gameSirControl = XSingleton<XUpdater.XUpdater>.singleton.GameSirControl;
				bool flag18 = gameSirControl != null && gameSirControl.IsConnected() && gameSirControl.GetButton(XGameSirKeyCode.BTN_THUMBR);
				if (flag18)
				{
					XOptionsDocument specificDocument = XDocuments.GetSpecificDocument<XOptionsDocument>(XOptionsDocument.uuID);
					int num = specificDocument.GetValue(XOptionsDefine.OD_VIEW) + 1;
					int num2 = XFastEnumIntEqualityComparer<XOperationMode>.ToInt(XOperationMode.X3D_Free);
					bool flag19 = num > num2;
					if (flag19)
					{
						num = XFastEnumIntEqualityComparer<XOperationMode>.ToInt(XOperationMode.X25D);
					}
					specificDocument.SetValue(XOptionsDefine.OD_VIEW, num, false);
					specificDocument.SetBattleOptionValue();
					this.SetView((XOperationMode)num);
				}
				this.TeamMonitor.OnUpdate();
				this.EnemyInfoHandler.OnUpdate();
				base.uiBehaviour.m_PlayerBuffMonitorHandler.OnUpdate();
				bool flag20 = this._combo_buff_to_add > this._combo_buff_added;
				if (flag20)
				{
					ComboBuff comboBuff = this._combo_buff_list[this._combo_buff_to_add];
					XBuff buffByID = XSingleton<XEntityMgr>.singleton.Player.Buffs.GetBuffByID(comboBuff.buffID);
					bool flag21 = buffByID != null;
					if (flag21)
					{
						this._combo_buff_added = this._combo_buff_to_add;
						this._combo_buff_to_add = -1;
					}
				}
				bool flag22 = this._combo_buff_added >= 0;
				if (flag22)
				{
					ComboBuff comboBuff2 = this._combo_buff_list[this._combo_buff_added];
					XBuff buffByID2 = XSingleton<XEntityMgr>.singleton.Player.Buffs.GetBuffByID(comboBuff2.buffID);
					bool flag23 = buffByID2 != null;
					if (flag23)
					{
						float leftTime = buffByID2.GetLeftTime();
						Color comboQuality = this.GetComboQuality(this._combo_buff_added + 1);
						base.uiBehaviour.m_ComboBuffName.SetText(comboBuff2.buffName);
						base.uiBehaviour.m_ComboBuffName.SetColor(comboQuality);
						base.uiBehaviour.m_ComboBuffTime.gameObject.SetActive(true);
						bool flag24 = leftTime != -1f;
						if (flag24)
						{
							base.uiBehaviour.m_ComboBuffTime.value = leftTime / buffByID2.Duration;
						}
						else
						{
							base.uiBehaviour.m_ComboBuffTime.value = 1f;
						}
					}
					else
					{
						this._combo_buff_added = -1;
						base.uiBehaviour.m_ComboBuffTime.gameObject.SetActive(false);
					}
				}
				else
				{
					base.uiBehaviour.m_ComboBuffTime.gameObject.SetActive(false);
				}
				bool flag25 = base.uiBehaviour.m_StrengthPresevedBar.IsVisible();
				if (flag25)
				{
					this.RefreshStrengthPresevedBar();
				}
			}
		}

		protected Color GetComboQuality(int quality)
		{
			Color result;
			switch (quality)
			{
			case 1:
				result = new Color32(0, byte.MaxValue, 18, byte.MaxValue);
				break;
			case 2:
				result = new Color32(0, 228, byte.MaxValue, byte.MaxValue);
				break;
			case 3:
				result = new Color32(byte.MaxValue, 180, 0, byte.MaxValue);
				break;
			case 4:
				result = new Color32(252, 0, byte.MaxValue, byte.MaxValue);
				break;
			default:
				result = new Color32(252, 0, byte.MaxValue, byte.MaxValue);
				break;
			}
			return result;
		}

		private void UpdateWifi()
		{
			XSingleton<UiUtility>.singleton.UpdateWifi(null, this.m_uiBehaviour.m_sprwifi);
		}

		private void RefreshPing()
		{
			XSingleton<UiUtility>.singleton.RefreshPing(base.uiBehaviour.m_lblTime, base.uiBehaviour.m_sliderBattery, base.uiBehaviour.m_lblfree);
		}

		public void RefreshBossRush()
		{
			XBossBushDocument xbossBushDocument = XSingleton<XGame>.singleton.Doc.GetXComponent(XBossBushDocument.uuID) as XBossBushDocument;
			bool flag = xbossBushDocument != null && XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_BOSSRUSH;
			if (flag)
			{
				this.m_uiBehaviour.m_sprBuff1.SetSprite(xbossBushDocument.bossBuff1Row.icon);
				this.m_uiBehaviour.m_sprBuff2.SetSprite(xbossBushDocument.bossBuff2Row.icon);
				this.m_uiBehaviour.m_lblBuff1.SetText(xbossBushDocument.bossBuff1Row.Comment);
				this.m_uiBehaviour.m_lblBuff2.SetText(xbossBushDocument.bossBuff2Row.Comment);
				int quality = xbossBushDocument.bossBuff1Row.Quality;
				int quality2 = xbossBushDocument.bossBuff2Row.Quality;
				string value = XSingleton<XGlobalConfig>.singleton.GetValue("Quality" + quality + "Color");
				string value2 = XSingleton<XGlobalConfig>.singleton.GetValue("Quality" + quality2 + "Color");
				this.m_uiBehaviour.m_sprBuff1.SetColor(XSingleton<UiUtility>.singleton.ParseColor(value, 0));
				this.m_uiBehaviour.m_sprBuff2.SetColor(XSingleton<UiUtility>.singleton.ParseColor(value2, 0));
				this.m_uiBehaviour.m_lblBuff1.SetColor(XSingleton<UiUtility>.singleton.ParseColor(value, 0));
				this.m_uiBehaviour.m_lblBuff2.SetColor(XSingleton<UiUtility>.singleton.ParseColor(value2, 0));
				base.uiBehaviour.m_lblTitle.SetText(XStringDefineProxy.GetString("BOSSRUSH_FIGHT", new object[]
				{
					xbossBushDocument.respData.currank
				}) + "  " + DlgBase<BossRushDlg, BossRushBehavior>.singleton.bossName);
				base.uiBehaviour.m_rwdpool.ReturnAll(false);
				for (int i = 0; i < xbossBushDocument.bossRushRow.reward.Count; i++)
				{
					uint itemid = xbossBushDocument.bossRushRow.reward[i, 0];
					uint num = xbossBushDocument.bossRushRow.reward[i, 1];
					GameObject gameObject = base.uiBehaviour.m_rwdpool.FetchGameObject(false);
					XSingleton<XItemDrawerMgr>.singleton.normalItemDrawer.DrawItem(gameObject, (int)itemid, (int)(num * xbossBushDocument.rwdRate), false);
					bool flag2 = i < 2;
					if (flag2)
					{
						gameObject.transform.localPosition = new Vector3((float)(10 + 100 * i), 0f, 0f);
					}
					else
					{
						gameObject.transform.localPosition = new Vector3((float)(10 + 100 * (i - 2)), -100f, 0f);
					}
				}
				base.uiBehaviour.m_sprBossbg.spriteHeight = ((xbossBushDocument.bossRushRow.reward.Count > 2) ? 207 : 137);
			}
		}

		public void UpdateKill(int cnt)
		{
			bool flag = base.IsVisible();
			if (flag)
			{
				string @string = XStringDefineProxy.GetString("SMALLMONSTER_KILL");
				base.uiBehaviour.m_lblKill.SetText(string.Format(XStringDefineProxy.GetString("SMALLMONSTER_KILL"), cnt));
			}
		}

		public void OnComboChange(uint combo)
		{
			bool flag = combo > 0u;
			if (flag)
			{
				this.m_uiBehaviour.m_ComboFrame.transform.localPosition = Vector3.zero;
				this.m_uiBehaviour.m_ComboText.SetText(combo.ToString());
				IXUITweenTool comboBgTween = this.m_uiBehaviour.m_ComboBgTween;
				comboBgTween.PlayTween(true, -1f);
				bool hasComboBuff = XSingleton<XScene>.singleton.SceneData.HasComboBuff;
				if (hasComboBuff)
				{
					int num = -1;
					bool flag2 = (ulong)combo < (ulong)((long)this._combo_buff_list[0].combo);
					if (flag2)
					{
						num = -1;
					}
					else
					{
						bool flag3 = (ulong)combo > (ulong)((long)this._combo_buff_list[this._combo_buff_list.Count - 1].combo);
						if (flag3)
						{
							num = -1;
						}
						else
						{
							for (int i = 0; i < this._combo_buff_list.Count - 1; i++)
							{
								bool flag4 = (ulong)combo == (ulong)((long)this._combo_buff_list[i].combo);
								if (flag4)
								{
									num = i;
									break;
								}
							}
						}
					}
					bool flag5 = num >= 0 && num <= this._combo_buff_list.Count - 1;
					if (flag5)
					{
						XBuffAddEventArgs @event = XEventPool<XBuffAddEventArgs>.GetEvent();
						@event.xBuffDesc.BuffID = this._combo_buff_list[num].buffID;
						@event.xBuffDesc.BuffLevel = this._combo_buff_list[num].buffLevel;
						@event.Firer = XSingleton<XEntityMgr>.singleton.Player;
						@event.xBuffDesc.CasterID = XSingleton<XEntityMgr>.singleton.Player.ID;
						XSingleton<XEventMgr>.singleton.FireEvent(@event);
						this._combo_buff_to_add = num;
					}
					else
					{
						base.uiBehaviour.m_ComboBuffTime.gameObject.SetActive(false);
					}
				}
				else
				{
					base.uiBehaviour.m_ComboBuffTime.gameObject.SetActive(false);
				}
			}
			else
			{
				this.m_uiBehaviour.m_ComboFrame.transform.localPosition = Vector3.one * (float)XGameUI._far_far_away;
			}
		}

		public void ShowNotice(string text, float duration, float pertime = 1f)
		{
			this._notice_collection.Clear();
			string[] array = text.Split(XGlobalConfig.ListSeparator);
			for (int i = 0; i < array.Length; i++)
			{
				this._notice_collection.Add(array[i]);
			}
			this._notice_duration = duration;
			this._notice_pertime = pertime;
			bool flag = this.time_token > 0u;
			if (flag)
			{
				XSingleton<XTimerMgr>.singleton.KillTimer(this.time_token);
				this.time_token = 0u;
			}
			bool flag2 = this._notice_collection.Count > 0;
			if (flag2)
			{
				this.ShowSingleNotice(0);
			}
		}

		protected void ShowSingleNotice(object o)
		{
			int num = (int)o;
			bool flag = num < this._notice_collection.Count;
			if (flag)
			{
				string text = this._notice_collection[num];
				base.uiBehaviour.m_Notice.SetText(text);
				base.uiBehaviour.m_NoticeFrame.transform.localPosition = base.uiBehaviour.m_NoticePos;
				this.NoticeTime = Time.time;
				this.time_token = XSingleton<XTimerMgr>.singleton.SetTimer(this._notice_pertime, this._showSingleNoticeCb, num + 1);
				bool flag2 = num == this._notice_collection.Count - 1;
				if (flag2)
				{
					this._notice_collection.Clear();
				}
			}
		}

		public void StopNotice()
		{
			bool flag = this.time_token > 0u;
			if (flag)
			{
				XSingleton<XTimerMgr>.singleton.KillTimer(this.time_token);
				this.time_token = 0u;
			}
			base.uiBehaviour.m_NoticeFrame.transform.localPosition = XGameUI.Far_Far_Away;
		}

		public void ShowSkillRemainingCD(string skillName, float time)
		{
			this.ShowBigNotice(XStringDefineProxy.GetString("SkillRemainingCD", new object[]
			{
				skillName,
				time.ToString()
			}), false);
		}

		public void ShowBigNotice(string text, bool bCmd)
		{
			bool flag = !base.IsVisible();
			if (!flag)
			{
				XSingleton<XTimerMgr>.singleton.KillTimer(this._big_notice_timer_token);
				bool flag2 = this._big_notice == null;
				if (flag2)
				{
					this._big_notice = (XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("UI/Common/TutorialButtomText", true, false) as GameObject);
					this._big_notice.transform.parent = base.uiBehaviour.transform;
					this._big_notice.transform.localPosition = Vector3.zero;
					this._big_notice.transform.localScale = Vector3.one;
				}
				IXUILabel ixuilabel = this._big_notice.transform.Find("TutorialText").GetComponent("XUILabel") as IXUILabel;
				ixuilabel.SetText(text);
				IXUITweenTool ixuitweenTool = this._big_notice.GetComponent("XUIPlayTween") as IXUITweenTool;
				ixuitweenTool.PlayTween(true, -1f);
				if (bCmd)
				{
					this._big_notice_timer_token = XSingleton<XTimerMgr>.singleton.SetTimer(5f, this._endBigNoticeCmdCb, null);
				}
				else
				{
					this._big_notice_timer_token = XSingleton<XTimerMgr>.singleton.SetTimer(3f, this._endBigNoticeCb, null);
				}
			}
		}

		protected void EndBigNotice(object o)
		{
			bool flag = this._big_notice != null;
			if (flag)
			{
				XResourceLoaderMgr.SafeDestroy(ref this._big_notice, true);
			}
			this._big_notice_timer_token = 0u;
		}

		protected void EndBigNoticeCmd(object o)
		{
			bool flag = this._big_notice != null;
			if (flag)
			{
				XResourceLoaderMgr.SafeDestroy(ref this._big_notice, true);
				XSingleton<XLevelScriptMgr>.singleton.ExecuteNextCmd();
			}
			this._big_notice_timer_token = 0u;
		}

		protected void ClearBigNotice()
		{
			bool flag = this._big_notice != null;
			if (flag)
			{
				XResourceLoaderMgr.SafeDestroy(ref this._big_notice, true);
			}
			XSingleton<XTimerMgr>.singleton.KillTimer(this._big_notice_timer_token);
			this._big_notice_timer_token = 0u;
		}

		public void ShowAutoReviveFrame(int time, uint cost, uint costType)
		{
			bool flag = base.uiBehaviour.m_WorldBossHandler != null && base.uiBehaviour.m_WorldBossHandler.active;
			if (flag)
			{
				base.uiBehaviour.m_WorldBossHandler.SetAutoRevive(time, cost, costType);
			}
		}

		public void OnPlayerRevive()
		{
			bool flag = base.uiBehaviour.m_WorldBossHandler != null && base.uiBehaviour.m_WorldBossHandler.active;
			if (flag)
			{
				base.uiBehaviour.m_WorldBossHandler.HideAutoRevive();
			}
			base.uiBehaviour.m_LowHP.SetActive(false);
		}

		public float GetLeftTime()
		{
			return this.leftTimeCounter.GetFloatLeftTime();
		}

		public void HideLeftTime()
		{
			this.timeConnter.SetLeftTime(0f, -1);
			this.leftTimeCounter.SetLeftTime(0f, -1);
			base.uiBehaviour.m_LeftTime.SetVisible(false);
			base.uiBehaviour.m_WarTime.SetVisible(false);
		}

		public void SetLeftTime(uint seconds, int noticeTime = -1)
		{
			base.uiBehaviour.m_LeftTime.SetVisible(true);
			this.leftTimeCounter.SetLeftTime(seconds, noticeTime);
			base.uiBehaviour.m_WarTime.SetVisible(false);
		}

		public void SetTimeRecord()
		{
			base.uiBehaviour.m_WarTime.SetVisible(true);
			this.timeConnter.SetForward(1);
			this.timeConnter.SetLeftTime(0.01f, -1);
			base.uiBehaviour.m_LeftTime.SetVisible(false);
		}

		public void ResetLeftTime(int seconds)
		{
			SceneTable.RowData sceneData = XSingleton<XSceneMgr>.singleton.GetSceneData(XSingleton<XScene>.singleton.SceneID);
			bool flag = sceneData.TimeCounter == null || sceneData.TimeCounter.Length < 1;
			if (flag)
			{
				this.timeConnter.SetLeftTime((float)seconds, -1);
			}
			else
			{
				bool flag2 = sceneData.TimeCounter[0] == 1;
				if (flag2)
				{
					this.leftTimeCounter.SetLeftTime((float)((int)sceneData.TimeCounter[1] - seconds), -1);
				}
			}
		}

		private void UpdateLeftTime()
		{
			bool sceneStarted = XSingleton<XScene>.singleton.SceneStarted;
			if (sceneStarted)
			{
				this.leftTimeCounter.Update();
			}
		}

		private void UpdateTime()
		{
			bool sceneStarted = XSingleton<XScene>.singleton.SceneStarted;
			if (sceneStarted)
			{
				this.timeConnter.Update();
			}
		}

		public void OnSwitchToTeamChat(object obj)
		{
			DlgBase<XChatView, XChatBehaviour>.singleton.SelectChatTeam();
		}

		public void OnVoiceButtonDrag(IXUIButton sp, Vector2 delta)
		{
			this.m_DragDistance += delta;
			bool flag = this.m_DragDistance.magnitude >= 100f;
			if (flag)
			{
				this.m_CancelRecord = true;
			}
			else
			{
				this.m_CancelRecord = false;
			}
		}

		public void OnVoiceButton(IXUIButton sp, bool state)
		{
			if (state)
			{
				XSingleton<XDebug>.singleton.AddLog("Press down", null, null, null, null, null, XDebugColor.XDebug_None);
				this.m_DragDistance = Vector2.zero;
				this.m_IsRecording = true;
				bool useApollo = XChatDocument.UseApollo;
				if (useApollo)
				{
					XSingleton<XChatApolloMgr>.singleton.StartRecord(VoiceUsage.CHAT, null);
				}
				else
				{
					XSingleton<XChatIFlyMgr>.singleton.StartRecord(VoiceUsage.CHAT, null);
				}
			}
			else
			{
				XSingleton<XDebug>.singleton.AddLog("Press up", null, null, null, null, null, XDebugColor.XDebug_None);
				this.m_IsRecording = false;
				DlgBase<XChatView, XChatBehaviour>.singleton.SetActiveChannel(ChatChannelType.Team);
				bool useApollo2 = XChatDocument.UseApollo;
				if (useApollo2)
				{
					XSingleton<XChatApolloMgr>.singleton.StopRecord(this.m_CancelRecord);
				}
				else
				{
					XSingleton<XChatIFlyMgr>.singleton.StopRecord(this.m_CancelRecord);
				}
			}
		}

		public void OnStopVoiceRecord()
		{
			bool isRecording = this.m_IsRecording;
			if (isRecording)
			{
				DlgBase<XChatView, XChatBehaviour>.singleton.SetActiveChannel(ChatChannelType.Team);
				bool useApollo = XChatDocument.UseApollo;
				if (useApollo)
				{
					XSingleton<XChatApolloMgr>.singleton.StopRecord(this.m_CancelRecord);
				}
				else
				{
					XSingleton<XChatIFlyMgr>.singleton.StopRecord(this.m_CancelRecord);
				}
				this.m_IsRecording = false;
			}
		}

		public bool OnCommandBtnClick(IXUIButton btn)
		{
			return true;
		}

		public bool OnAutoPlay(IXUIButton sp)
		{
			bool flag = !base.IsLoaded();
			return flag || this.SetAutoPlay(sp.ID == 1UL);
		}

		private bool OnHorseRideClicked(IXUIButton btn)
		{
			bool flag = !base.IsLoaded();
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				XPetDocument specificDocument = XDocuments.GetSpecificDocument<XPetDocument>(XPetDocument.uuID);
				specificDocument.ReqRecentMount();
				result = true;
			}
			return result;
		}

		private bool SetAutoPlay(bool isAuto)
		{
			XPlayerAttributes xplayerAttributes = XSingleton<XEntityMgr>.singleton.Player.Attributes as XPlayerAttributes;
			xplayerAttributes.AutoPlayOn = isAuto;
			XAIComponent ai = XSingleton<XEntityMgr>.singleton.Player.AI;
			bool flag = ai != null && !XSingleton<XScene>.singleton.bSpectator;
			if (flag)
			{
				XAIEnableAI @event = XEventPool<XAIEnableAI>.GetEvent();
				@event.Firer = XSingleton<XEntityMgr>.singleton.Player;
				@event.Enable = isAuto;
				@event.Puppet = false;
				XSingleton<XEventMgr>.singleton.FireEvent(@event);
			}
			bool autoPlayOn = xplayerAttributes.AutoPlayOn;
			if (autoPlayOn)
			{
				base.uiBehaviour.m_AutoPlayBorad.SetVisible(false);
				base.uiBehaviour.m_AutoPlayCancelBoard.SetVisible(true);
				XSingleton<UiUtility>.singleton.ShowSystemNoticeTip(XStringDefineProxy.GetString("AutoPlayNotice"));
			}
			else
			{
				base.uiBehaviour.m_AutoPlayBorad.SetVisible(true);
				base.uiBehaviour.m_AutoPlayCancelBoard.SetVisible(false);
			}
			return true;
		}

		private void OnAutoPlayTip(IXUISprite go)
		{
			bool flag = !base.IsLoaded();
			if (!flag)
			{
				bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_ARENA;
				if (flag2)
				{
					XSingleton<UiUtility>.singleton.ShowSystemNoticeTip(XStringDefineProxy.GetString("ArenaAutoFight"));
				}
				else
				{
					XSingleton<UiUtility>.singleton.ShowSystemNoticeTip(string.Format(XStringDefineProxy.GetString("AutoFightOpenLevel"), XSingleton<XGlobalConfig>.singleton.GetValue("AutoPlayUnlockLevel")));
				}
			}
		}

		private bool OnBattleStatisticsClick(IXUIButton btn)
		{
			bool flag = base.uiBehaviour == null;
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				DlgHandlerBase.EnsureCreate<BattleStatisticsHandler>(ref this.m_BattleStatisticsHandler, base.uiBehaviour.m_canvas.transform, this.m_BattleStatisticsHandler == null || !this.m_BattleStatisticsHandler.IsVisible(), this);
				result = true;
			}
			return result;
		}

		public void ShowBattleVoice(ChatVoiceInfo info)
		{
			bool flag = !base.IsVisible();
			if (!flag)
			{
				this.m_ChatLabelCd = XSingleton<XTimerMgr>.singleton.SetTimer((float)info.voiceTime + 2f, this._hideBattleChatUICb, info);
			}
		}

		public void HideBattleChatUI(object info)
		{
			this.m_ChatLabelCd = 0u;
		}

		public void ShowCountDownFrame(bool status)
		{
			bool flag = !base.IsVisible();
			if (!flag)
			{
				base.uiBehaviour.m_CountDownFrame.gameObject.SetActive(true);
				base.uiBehaviour.m_CountDownTimeFrame.gameObject.SetActive(status);
				base.uiBehaviour.m_CountDownBeginFrame.gameObject.SetActive(!status);
				(base.uiBehaviour.m_CountDownTimeFrame.gameObject.GetComponent("XUIPlayTween") as IXUITweenTool).PlayTween(status, -1f);
				(base.uiBehaviour.m_CountDownBeginFrame.gameObject.GetComponent("XUIPlayTween") as IXUITweenTool).PlayTween(!status, -1f);
			}
		}

		public void SetAutoPlayUI(bool isInAutoPlay)
		{
			bool flag = !this._can_auto_play;
			if (!flag)
			{
				this.SetAutoPlay(isInAutoPlay);
			}
		}

		public void OnPlaySuperarmorFx(XEntity enemy, bool bBroken)
		{
			for (int i = 0; i < this.EnemyInfoHandler.EnemyList.Count; i++)
			{
				bool flag = this.EnemyInfoHandler.EnemyList[i].Entity == enemy;
				if (flag)
				{
					this.EnemyInfoHandler.EnemyList[i].SetSuperArmorState(bBroken);
					break;
				}
			}
		}

		public void OnStopSuperarmorFx(XEntity enemy)
		{
			for (int i = 0; i < this.EnemyInfoHandler.EnemyList.Count; i++)
			{
				bool flag = this.EnemyInfoHandler.EnemyList[i].Entity == enemy;
				if (flag)
				{
					this.EnemyInfoHandler.EnemyList[i].StopSuperArmorFx();
					break;
				}
			}
		}

		public void OnProjectDamage(ProjectDamageResult damage, XEntity entity)
		{
			for (int i = 0; i < this.EnemyInfoHandler.EnemyList.Count; i++)
			{
				bool flag = this.EnemyInfoHandler.EnemyList[i].Entity == entity;
				if (flag)
				{
					bool flag2 = damage.Caster == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
					if (flag2)
					{
						this.EnemyInfoHandler.EnemyList[i].OnBeHit(damage);
					}
					break;
				}
			}
		}

		public void SetupSpeedFx(XEntity enemy, bool enable, Color c)
		{
			for (int i = 0; i < this.EnemyInfoHandler.EnemyList.Count; i++)
			{
				bool flag = this.EnemyInfoHandler.EnemyList[i].Entity == enemy;
				if (flag)
				{
					IXUISprite uiSuperArmorSpeedFx = this.EnemyInfoHandler.EnemyList[i].m_uiSuperArmorSpeedFx;
					uiSuperArmorSpeedFx.gameObject.SetActive(enable);
					uiSuperArmorSpeedFx.SetColor(c);
					break;
				}
			}
		}

		public void ShowStrengthPresevedBar(XEntity entity)
		{
			base.uiBehaviour.m_StrengthPresevedBar.SetVisible(true);
			this._strength_preseved_entity = entity;
			this._total_strength_preseved = (float)this._strength_preseved_entity.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentXULI_Basic);
			this._current_strength_preseved = this._total_strength_preseved;
			this.RefreshStrengthPresevedBar();
		}

		public void HideStrengthPresevedBar()
		{
			base.uiBehaviour.m_StrengthPresevedBar.SetVisible(false);
			this._strength_preseved_entity = null;
			this._total_strength_preseved = 1f;
			this._current_strength_preseved = 0f;
		}

		public void RefreshStrengthPresevedBar()
		{
			bool flag = this._strength_preseved_entity != null && this._strength_preseved_entity.Attributes != null;
			if (flag)
			{
				this._current_strength_preseved = (float)this._strength_preseved_entity.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentXULI_Basic);
			}
			bool flag2 = base.uiBehaviour != null && base.uiBehaviour.m_StrengthPresevedBar != null;
			if (flag2)
			{
				base.uiBehaviour.m_StrengthPresevedBar.value = this._strength_preseved_precent;
			}
		}

		public void SetTargetTabVisable(bool status)
		{
		}

		public void OnTargetTabClick(IXUISprite sp)
		{
		}

		public bool OnSightSelectClick(IXUIButton sp)
		{
			bool flag = !base.IsLoaded();
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				this.SetView((XOperationMode)sp.ID);
				result = true;
			}
			return result;
		}

		public bool OnSightClick(IXUIButton sp)
		{
			bool flag = !base.IsLoaded();
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				bool flag2 = base.uiBehaviour == null || base.uiBehaviour.m_SightSelect == null;
				if (flag2)
				{
					result = false;
				}
				else
				{
					bool activeSelf = base.uiBehaviour.m_SightSelect.gameObject.activeSelf;
					if (activeSelf)
					{
						base.uiBehaviour.m_SightSelect.gameObject.SetActive(false);
					}
					else
					{
						base.uiBehaviour.m_SightSelect.gameObject.SetActive(true);
					}
					result = true;
				}
			}
			return result;
		}

		public void OnSpectateMessageChange(int watchNum, int commendNum)
		{
			XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument<XSpectateSceneDocument>(XSpectateSceneDocument.uuID);
			bool spectateInfoIsShow = this.SpectateInfoIsShow;
			if (spectateInfoIsShow)
			{
				base.uiBehaviour.m_WatchNum.SetText(watchNum.ToString());
				base.uiBehaviour.m_CommendNum.SetText(commendNum.ToString());
			}
			else
			{
				bool flag = watchNum >= specificDocument.WatchTarget || commendNum >= specificDocument.CommendTarget;
				if (flag)
				{
					XSingleton<XDebug>.singleton.AddLog("watchNum and commendNum are enough now.", null, null, null, null, null, XDebugColor.XDebug_None);
					this.SpectateInfoIsShow = true;
					base.uiBehaviour.m_SpectateInfo.transform.localPosition = Vector3.zero;
					base.uiBehaviour.m_WatchNum.SetText(watchNum.ToString());
					base.uiBehaviour.m_CommendNum.SetText(commendNum.ToString());
				}
			}
		}

		public void ShowGuildMineBuff(ResWarBuffRes data)
		{
			bool flag = data == null || !base.IsLoaded();
			if (!flag)
			{
				bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_RESWAR_PVE;
				if (flag2)
				{
					GuildMineralBufflist.RowData mineBuffData = XGuildMineMainDocument.GetMineBuffData(data.buffid);
					bool flag3 = mineBuffData == null;
					if (flag3)
					{
						XSingleton<XDebug>.singleton.AddErrorLog("buffid:" + data.buffid, null, null, null, null, null);
					}
					else
					{
						uint num = mineBuffData.Quality - 1u;
						base.uiBehaviour.m_GuildMineBuff.gameObject.SetActive(true);
						base.uiBehaviour.m_GuildMineBuff.SetSprite(mineBuffData.icon);
						base.uiBehaviour.m_GuildMineBuffText.SetText(mineBuffData.ratestring);
						bool flag4 = (ulong)num >= (ulong)((long)DlgBase<GuildMineMainView, GuildMineMainBehaviour>.singleton.BossColor.Length);
						if (flag4)
						{
							XSingleton<XDebug>.singleton.AddErrorLog(string.Concat(new object[]
							{
								"bossMineBuffIndex:",
								num,
								"\nBossColor:",
								DlgBase<GuildMineMainView, GuildMineMainBehaviour>.singleton.BossColor.Length
							}), null, null, null, null, null);
							num = 0u;
						}
						bool flag5 = (ulong)num < (ulong)((long)DlgBase<GuildMineMainView, GuildMineMainBehaviour>.singleton.BossColor.Length);
						if (flag5)
						{
							base.uiBehaviour.m_GuildMineBuff.SetColor(XSingleton<UiUtility>.singleton.ParseColor(DlgBase<GuildMineMainView, GuildMineMainBehaviour>.singleton.BossColor[(int)num], 0));
							base.uiBehaviour.m_GuildMineBuffText.SetColor(XSingleton<UiUtility>.singleton.ParseColor(DlgBase<GuildMineMainView, GuildMineMainBehaviour>.singleton.BossColor[(int)num], 0));
						}
					}
				}
			}
		}

		public void SetLoadingPrompt(List<string> otherPalyerName, bool canAutoClose = false)
		{
			bool flag = !base.IsLoaded() || XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.World || !XSingleton<XGame>.singleton.SyncMode;
			if (!flag)
			{
				bool flag2 = otherPalyerName == null || otherPalyerName.Count == 0;
				if (flag2)
				{
					this.m_uiBehaviour.m_PromptLabel.SetText(XStringDefineProxy.GetString("WAIT_FOR_OTHERS"));
					bool flag3 = canAutoClose && this.m_uiBehaviour.m_PromptFrame.gameObject.activeSelf;
					if (flag3)
					{
						this.m_uiBehaviour.m_PromptFrame.gameObject.SetActive(false);
					}
				}
				else
				{
					string text = string.Format(XSingleton<UiUtility>.singleton.ReplaceReturn(XSingleton<XStringTable>.singleton.GetString("WAIT_OTHER_PLAYER_PVP")), otherPalyerName.Count, otherPalyerName[0]);
					this.m_uiBehaviour.m_PromptLabel.SetText(text);
				}
			}
		}
	}
}