+scripts

1 files changed, 475 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/UI/BattleWorldBossHandler.cs b/Client/Assets/Scripts/XMainClient/UI/BattleWorldBossHandler.cs
new file mode 100644
index 00000000..2b0ef05f
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/UI/BattleWorldBossHandler.cs
@@ -0,0 +1,475 @@
+using System;

+using System.Collections.Generic;

+using KKSG;

+using UILib;

+using UnityEngine;

+using XMainClient.UI.UICommon;

+using XUtliPoolLib;

+

+namespace XMainClient.UI

+{

+	internal class BattleWorldBossHandler : DlgHandlerBase, IWorldBossBattleView

+	{

+		private IXUIButton _DamageRankBtn;

+

+		private GameObject _EncouragePanel;

+

+		private IXUIButton _DoEncourage;

+

+		private IXUISprite _EncourageClose;

+

+		private IXUILabel _CurrentEncourageEffect;

+

+		private IXUILabel _CurrentEncourageTitle;

+

+		private IXUILabel _CurrentEncourageType;

+

+		private IXUILabel _EncourageEffect;

+

+		private IXUILabel _EncourageMoneyCost;

+

+		private IXUITweenTool _CurrentEncourageEffectTween;

+

+		private GameObject _RankPanel;

+

+		private GameObject _AutoRevivePanel;

+

+		private IXUILabel _AutoReviveLeftTime;

+

+		private IXUILabel _ReviveCost;

+

+		private IXUISprite _ReviveCostIcon;

+

+		private IXUIButton _DoRevive;

+

+		public IXUITweenTool m_EncourageFrameTween;

+

+		public IXUITweenTool m_RankFrameTween;

+

+		private XWorldBossDamageRankHandler _RankHandler;

+

+		public IWorldBossBattleSource BattleSource;

+

+		private XElapseTimer m_AutoReviveLeftTime = new XElapseTimer();

+

+		private int m_nAutoReviveLeftTime;

+

+		private uint _GetBattleInfoToken;

+

+		private EncourageShowInfo[] m_encourageInfos;

+

+		private uint _LeaveSceneToken = 0u;

+

+		private uint _LeaveSceneTime = 0u;

+

+		private int _SelectIndex = 0;

+

+		protected override void Init()

+		{

+			base.Init();

+			this._DamageRankBtn = (base.PanelObject.transform.Find("DamageRankBtn").GetComponent("XUIButton") as IXUIButton);

+			this.m_encourageInfos = new EncourageShowInfo[2];

+			this.m_encourageInfos[0] = new EncourageShowInfo(base.PanelObject.transform.Find("EncourageBtn0"), base.PanelObject.transform.Find("GuildBossbuff"), 0);

+			this.m_encourageInfos[1] = new EncourageShowInfo(base.PanelObject.transform.Find("EncourageBtn1"), base.PanelObject.transform.Find("GuildBossbuff1"), 1);

+			this._EncouragePanel = base.PanelObject.transform.Find("EncourageMenu").gameObject;

+			this._DoEncourage = (this._EncouragePanel.transform.Find("Do").GetComponent("XUIButton") as IXUIButton);

+			this._EncourageClose = (this._EncouragePanel.transform.Find("Close").GetComponent("XUISprite") as IXUISprite);

+			this._CurrentEncourageEffect = (this._EncouragePanel.transform.Find("CurrentEffect").GetComponent("XUILabel") as IXUILabel);

+			this._CurrentEncourageEffectTween = (this._EncouragePanel.transform.Find("CurrentEffect").GetComponent("XUIPlayTween") as IXUITweenTool);

+			this._CurrentEncourageTitle = (this._EncouragePanel.transform.Find("CurrentTitle").GetComponent("XUILabel") as IXUILabel);

+			this._CurrentEncourageType = (this._EncouragePanel.transform.Find("CurrentType").GetComponent("XUILabel") as IXUILabel);

+			this._EncourageEffect = (this._EncouragePanel.transform.Find("Effect").GetComponent("XUILabel") as IXUILabel);

+			this._EncourageMoneyCost = (this._EncouragePanel.transform.Find("Do/MoneyCost").GetComponent("XUILabel") as IXUILabel);

+			this._RankPanel = base.PanelObject.transform.Find("WorldBossRankPanel").gameObject;

+			this._AutoRevivePanel = base.PanelObject.transform.Find("AutoRevivePanel").gameObject;

+			this._AutoReviveLeftTime = (this._AutoRevivePanel.transform.Find("LeftTime").GetComponent("XUILabel") as IXUILabel);

+			this._ReviveCost = (this._AutoRevivePanel.transform.Find("DoRightnow/MoneyCost").GetComponent("XUILabel") as IXUILabel);

+			this._ReviveCostIcon = (this._AutoRevivePanel.transform.Find("DoRightnow/MoneyCost/Icon").GetComponent("XUISprite") as IXUISprite);

+			this._DoRevive = (this._AutoRevivePanel.transform.Find("DoRightnow").GetComponent("XUIButton") as IXUIButton);

+			this.m_EncourageFrameTween = (this._EncouragePanel.GetComponent("XUIPlayTween") as IXUITweenTool);

+			this.m_RankFrameTween = (this._RankPanel.GetComponent("XUIPlayTween") as IXUITweenTool);

+			DlgHandlerBase.EnsureCreate<XWorldBossDamageRankHandler>(ref this._RankHandler, this._RankPanel, null, true);

+			this._EncouragePanel.SetActive(false);

+			this._AutoRevivePanel.SetActive(false);

+			this._RankHandler.SetVisible(false);

+			this._SetupRank();

+		}

+

+		public override void RegisterEvent()

+		{

+			base.RegisterEvent();

+			for (int i = 0; i < this.m_encourageInfos.Length; i++)

+			{

+				this.m_encourageInfos[i].RegisterCourageClick(new ButtonClickEventHandler(this._OnEncouragePanelClicked));

+			}

+			this._DamageRankBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this._OnDamageRankClicked));

+			this._DoEncourage.RegisterClickEventHandler(new ButtonClickEventHandler(this._OnEncourageDoClicked));

+			this._EncourageClose.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this._OnEncourageCloseClicked));

+			this._DoRevive.RegisterClickEventHandler(new ButtonClickEventHandler(this._OnReviveDoClicked));

+			this.m_RankFrameTween.RegisterOnFinishEventHandler(new OnTweenFinishEventHandler(this._OnTweenFinishEventHandler));

+		}

+

+		public override void OnUpdate()

+		{

+			base.OnUpdate();

+			bool flag = this._RankHandler != null && this._RankHandler.active;

+			if (flag)

+			{

+				this._RankHandler.OnUpdate();

+			}

+			bool activeInHierarchy = this._AutoRevivePanel.activeInHierarchy;

+			if (activeInHierarchy)

+			{

+				this.m_AutoReviveLeftTime.Update();

+				int num = (int)this.m_AutoReviveLeftTime.LeftTime;

+				bool flag2 = num != this.m_nAutoReviveLeftTime;

+				if (flag2)

+				{

+					this.m_nAutoReviveLeftTime = num;

+					this._AutoReviveLeftTime.SetText(XSingleton<UiUtility>.singleton.TimeFormatString(this.m_nAutoReviveLeftTime, 2, 3, 4, false, true));

+				}

+			}

+		}

+

+		public override void OnUnload()

+		{

+			DlgHandlerBase.EnsureUnload<XWorldBossDamageRankHandler>(ref this._RankHandler);

+			for (int i = 0; i < this.m_encourageInfos.Length; i++)

+			{

+				bool flag = this.m_encourageInfos[i] != null;

+				if (flag)

+				{

+					this.m_encourageInfos[i].OnDispose();

+				}

+				this.m_encourageInfos[i] = null;

+			}

+			this.m_encourageInfos = null;

+			SceneType sceneType = XSingleton<XScene>.singleton.SceneType;

+			SceneType sceneType2 = sceneType;

+			if (sceneType2 != SceneType.SCENE_WORLDBOSS)

+			{

+				if (sceneType2 == SceneType.SCENE_GUILD_BOSS)

+				{

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

+					specificDocument.BattleHandler = null;

+				}

+			}

+			else

+			{

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

+				specificDocument2.BattleHandler = null;

+			}

+			this.BattleSource = null;

+			bool flag2 = this._LeaveSceneToken > 0u;

+			if (flag2)

+			{

+				XSingleton<XTimerMgr>.singleton.KillTimer(this._LeaveSceneToken);

+				this._LeaveSceneToken = 0u;

+			}

+			base.OnUnload();

+		}

+

+		private void _SetupRank()

+		{

+			List<RankeType> list = new List<RankeType>();

+			SceneType sceneType = XSingleton<XScene>.singleton.SceneType;

+			SceneType sceneType2 = sceneType;

+			if (sceneType2 != SceneType.SCENE_WORLDBOSS)

+			{

+				if (sceneType2 == SceneType.SCENE_GUILD_BOSS)

+				{

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

+					this.BattleSource = specificDocument;

+					this._RankHandler.RankSource = specificDocument;

+					specificDocument.BattleHandler = this;

+					specificDocument.RankHandler = this._RankHandler;

+					list.Add(RankeType.GuildBossRoleRank);

+					this.m_encourageInfos[0].Valid = true;

+					this.m_encourageInfos[0].attr_string = "GuildBossAddAttr";

+					this.m_encourageInfos[0].cost_string = "GuildBossConsume";

+					this.m_encourageInfos[0].encourage_type = "GUILDBOSS_ENCOURAGE_TYPE";

+					this.m_encourageInfos[0].encourage_title = "GUILDBOSS_ENCOURAGE_TITLE";

+					this.m_encourageInfos[0].encourage_effect = "GUILDBOSS_ENCOURAGE_EFFECT";

+					this.m_encourageInfos[0].BattleSource = specificDocument;

+					this.m_encourageInfos[0].ReqEncourage = new Action(specificDocument.ReqEncourage);

+					this.m_encourageInfos[1].Valid = false;

+				}

+			}

+			else

+			{

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

+				this.BattleSource = specificDocument2;

+				this._RankHandler.RankSource = specificDocument2;

+				specificDocument2.BattleHandler = this;

+				specificDocument2.RankHandler = this._RankHandler;

+				list.Add(RankeType.WorldBossDamageRank);

+				list.Add(RankeType.WorldBossGuildRank);

+				this.m_encourageInfos[0].Valid = true;

+				this.m_encourageInfos[0].attr_string = "WorldBossAddAttr";

+				this.m_encourageInfos[0].cost_string = "WorldBossConsume";

+				this.m_encourageInfos[0].encourage_type = "WORLDBOSS_ENCOURAGE_TYPE";

+				this.m_encourageInfos[0].encourage_title = "WORLDBOSS_ENCOURAGE_TITLE";

+				this.m_encourageInfos[0].encourage_effect = "WORLDBOSS_ENCOURAGE_EFFECT";

+				this.m_encourageInfos[0].ReqEncourage = new Action(specificDocument2.ReqEncourage);

+				this.m_encourageInfos[0].BattleSource = specificDocument2;

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

+				bool bInGuild = specificDocument3.bInGuild;

+				if (bInGuild)

+				{

+					this.m_encourageInfos[1].Valid = true;

+					this.m_encourageInfos[1].attr_string = "WorldBossGuildAddAttr";

+					this.m_encourageInfos[1].cost_string = "WorldBossGuildConsume";

+					this.m_encourageInfos[1].encourage_type = "GUILDBOSS_ENCOURAGE_TYPE";

+					this.m_encourageInfos[1].encourage_title = "GUILDBOSS_ENCOURAGE_TITLE";

+					this.m_encourageInfos[1].encourage_effect = "GUILDBOSS_ENCOURAGE_EFFECT";

+					this.m_encourageInfos[1].ReqEncourage = new Action(specificDocument2.ReqEncourageTwo);

+					this.m_encourageInfos[1].BattleSource = specificDocument2;

+					list.Add(RankeType.WorldBossGuildRoleRank);

+				}

+				else

+				{

+					this.m_encourageInfos[1].Valid = false;

+				}

+			}

+			this._RankHandler.SetupRanks(list, true);

+		}

+

+		protected override void OnShow()

+		{

+			base.OnShow();

+			this.ReqBattleInfo();

+			this._OnDamageRankClicked(this._DamageRankBtn);

+		}

+

+		private void ReqBattleInfo()

+		{

+			this.BattleSource.ReqBattleInfo();

+			XSingleton<XTimerMgr>.singleton.KillTimer(this._GetBattleInfoToken);

+			this._GetBattleInfoToken = XSingleton<XTimerMgr>.singleton.SetTimer(10f, new XTimerMgr.ElapsedEventHandler(this.ReqBattleInfoTimer), null);

+		}

+

+		private void ReqBattleInfoTimer(object o)

+		{

+			this.ReqBattleInfo();

+		}

+

+		protected override void OnHide()

+		{

+			bool flag = this._LeaveSceneToken > 0u;

+			if (flag)

+			{

+				XSingleton<XTimerMgr>.singleton.KillTimer(this._LeaveSceneToken);

+				this._LeaveSceneToken = 0u;

+			}

+			base.OnHide();

+		}

+

+		public void RefreshAllEnacourage()

+		{

+			bool flag = this.m_encourageInfos == null;

+			if (!flag)

+			{

+				int i = 0;

+				int num = this.m_encourageInfos.Length;

+				while (i < num)

+				{

+					EncourageShowInfo encourageShowInfo = this.m_encourageInfos[i];

+					bool flag2 = encourageShowInfo == null || !encourageShowInfo.Valid;

+					if (flag2)

+					{

+						break;

+					}

+					this.RefreshEncourage(i);

+					i++;

+				}

+			}

+		}

+

+		public void RefreshEncourage()

+		{

+			this.RefreshEncourage(this._SelectIndex);

+		}

+

+		public void RefreshEncourage(int index)

+		{

+			bool flag = !base.IsVisible();

+			if (!flag)

+			{

+				EncourageShowInfo encourageShowInfo = this.m_encourageInfos[index];

+				bool flag2 = encourageShowInfo == null || !encourageShowInfo.Valid;

+				if (!flag2)

+				{

+					string[] array = XSingleton<XGlobalConfig>.singleton.GetValue(encourageShowInfo.attr_string).Split(XGlobalConfig.ListSeparator);

+					string[] array2 = array[0].Split(XGlobalConfig.SequenceSeparator);

+					int num = int.Parse(array2[1]);

+					encourageShowInfo.SetEncourageValue(num);

+					bool flag3 = index == this._SelectIndex;

+					if (flag3)

+					{

+						this._EncourageEffect.SetText(XStringDefineProxy.GetString(encourageShowInfo.encourage_effect, new object[]

+						{

+							num

+						}));

+						this._CurrentEncourageTitle.SetText(XStringDefineProxy.GetString(encourageShowInfo.encourage_title));

+						this._CurrentEncourageType.SetText(XStringDefineProxy.GetString(encourageShowInfo.encourage_type));

+						this._CurrentEncourageEffect.SetText(string.Format("{0}%", (long)num * (long)((ulong)encourageShowInfo.EncourageCount)));

+						this._CurrentEncourageEffectTween.ResetTween(true);

+						this._CurrentEncourageEffectTween.PlayTween(true, 0.5f);

+						CostInfo costInfo = XSingleton<XTakeCostMgr>.singleton.QueryCost(encourageShowInfo.cost_string, (int)encourageShowInfo.EncourageCount);

+						this._EncourageMoneyCost.SetText(costInfo.count.ToString());

+					}

+				}

+			}

+		}

+

+		private bool _OnEncouragePanelClicked(IXUIButton btn)

+		{

+			this._SelectIndex = (int)btn.ID;

+			XSingleton<XDebug>.singleton.AddGreenLog("_OnEncouragePanelClicked" + this._SelectIndex.ToString(), null, null, null, null, null);

+			this.RefreshEncourage();

+			this.m_EncourageFrameTween.PlayTween(true, -1f);

+			return true;

+		}

+

+		private bool _OnDamageRankClicked(IXUIButton btn)

+		{

+			bool flag = !base.IsVisible();

+			bool result;

+			if (flag)

+			{

+				result = false;

+			}

+			else

+			{

+				IXUISprite ixuisprite = btn.gameObject.GetComponent("XUISprite") as IXUISprite;

+				bool flag2 = ixuisprite == null || this._RankHandler == null || this.m_RankFrameTween == null;

+				if (flag2)

+				{

+					result = false;

+				}

+				else

+				{

+					bool flag3 = !this._RankHandler.active;

+					if (flag3)

+					{

+						this._RankHandler.SetVisible(true);

+						this.m_RankFrameTween.PlayTween(true, -1f);

+						ixuisprite.SetFlipHorizontal(true);

+					}

+					else

+					{

+						this.m_RankFrameTween.PlayTween(false, -1f);

+						ixuisprite.SetFlipHorizontal(false);

+					}

+					result = true;

+				}

+			}

+			return result;

+		}

+

+		private void _OnTweenFinishEventHandler(IXUITweenTool tween)

+		{

+			bool flag = !tween.bPlayForward && this._RankHandler != null;

+			if (flag)

+			{

+				this._RankHandler.SetVisible(false);

+			}

+		}

+

+		private void _OnEncourageCloseClicked(IXUISprite iSp)

+		{

+			this._EncouragePanel.SetActive(false);

+		}

+

+		private bool _OnEncourageDoClicked(IXUIButton btn)

+		{

+			EncourageShowInfo encourageShowInfo = this.m_encourageInfos[this._SelectIndex];

+			bool flag = encourageShowInfo == null || encourageShowInfo.ReqEncourage == null;

+			bool result;

+			if (flag)

+			{

+				result = false;

+			}

+			else

+			{

+				CostInfo costInfo = XSingleton<XTakeCostMgr>.singleton.QueryCost(encourageShowInfo.cost_string, (int)encourageShowInfo.EncourageCount);

+				ulong itemCount = XBagDocument.BagDoc.GetItemCount(XFastEnumIntEqualityComparer<ItemEnum>.ToInt(ItemEnum.DRAGON_COIN));

+				bool flag2 = (ulong)costInfo.count > itemCount;

+				if (flag2)

+				{

+					XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("ERR_AUCT_DRAGONCOINLESS"), "fece00");

+				}

+				else

+				{

+					encourageShowInfo.ReqEncourage();

+				}

+				result = true;

+			}

+			return result;

+		}

+

+		public void SetLeftTime(uint leftTime)

+		{

+			bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();

+			if (flag)

+			{

+				DlgBase<BattleMain, BattleMainBehaviour>.singleton.SetLeftTime(leftTime, -1);

+			}

+			bool flag2 = DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.IsLoaded();

+			if (flag2)

+			{

+				DlgBase<SpectateSceneView, SpectateSceneBehaviour>.singleton.SetLeftTime(leftTime);

+			}

+		}

+

+		private bool _OnReviveDoClicked(IXUIButton btn)

+		{

+			RpcC2G_Revive rpcC2G_Revive = new RpcC2G_Revive();

+			rpcC2G_Revive.oArg.selectBuff = 0u;

+			rpcC2G_Revive.oArg.type = ReviveType.ReviveItem;

+			XSingleton<XClientNetwork>.singleton.Send(rpcC2G_Revive);

+			return true;

+		}

+

+		public void SetAutoRevive(int leftTime, uint cost, uint costType)

+		{

+			bool flag = leftTime <= 0;

+			if (!flag)

+			{

+				this._AutoRevivePanel.SetActive(true);

+				this.m_AutoReviveLeftTime.LeftTime = (float)leftTime;

+				this._AutoReviveLeftTime.SetText(XSingleton<UiUtility>.singleton.TimeFormatString(leftTime, 2, 3, 4, false, true));

+				this._ReviveCost.SetText(cost.ToString());

+				string itemSmallIcon = XBagDocument.GetItemSmallIcon((int)costType, 0u);

+				this._ReviveCostIcon.SetSprite(itemSmallIcon);

+			}

+		}

+

+		public void HideAutoRevive()

+		{

+			this._AutoRevivePanel.SetActive(false);

+		}

+

+		public void OnLeaveSceneCountDown(uint time)

+		{

+			this._LeaveSceneTime = time;

+			XSingleton<UiUtility>.singleton.ShowSystemTip(XSingleton<XStringTable>.singleton.GetString("WORLDBOSS_LEAVE_SCENE_TIP"), "fece00");

+			XSingleton<XTimerMgr>.singleton.KillTimer(this._LeaveSceneToken);

+			this._LeaveSceneToken = XSingleton<XTimerMgr>.singleton.SetTimer(1f, new XTimerMgr.ElapsedEventHandler(this.ShowLeaveSceneTip), null);

+		}

+

+		private void ShowLeaveSceneTip(object o)

+		{

+			XSingleton<UiUtility>.singleton.ShowSystemTip(this._LeaveSceneTime.ToString(), "fece00");

+			this._LeaveSceneTime -= 1u;

+			XSingleton<XTimerMgr>.singleton.KillTimer(this._LeaveSceneToken);

+			this._LeaveSceneToken = XSingleton<XTimerMgr>.singleton.SetTimer(1f, new XTimerMgr.ElapsedEventHandler(this.ShowLeaveSceneTip), null);

+			bool flag = this._LeaveSceneTime <= 0u && this._LeaveSceneToken > 0u;

+			if (flag)

+			{

+				XSingleton<XTimerMgr>.singleton.KillTimer(this._LeaveSceneToken);

+				this._LeaveSceneToken = 0u;

+			}

+		}

+	}

+}