+scripts

1 files changed, 618 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/UI/DragonCrusadeDlg.cs b/Client/Assets/Scripts/XMainClient/UI/DragonCrusadeDlg.cs
new file mode 100644
index 00000000..faf13010
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/UI/DragonCrusadeDlg.cs
@@ -0,0 +1,618 @@
+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 DragonCrusadeDlg : DlgBase<DragonCrusadeDlg, DragonCrusadeBehavior>

+	{

+		public override string fileName

+		{

+			get

+			{

+				return "DragonCrusade/DragonCrusadeDlg";

+			}

+		}

+

+		public override bool hideMainMenu

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override bool pushstack

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override bool autoload

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public bool isHallUI

+		{

+			get

+			{

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

+			}

+		}

+

+		public override bool fullscreenui

+		{

+			get

+			{

+				return true;

+			}

+		}

+

+		public override int sysid

+		{

+			get

+			{

+				return 50;

+			}

+		}

+

+		private XDragonCrusadeDocument mDoc = null;

+

+		private GameObject goDragonExpedition = null;

+

+		private IXDragonExpedition ixDragonExpedition = null;

+

+		private XFx _FxFirework = null;

+

+		private const int MAX_RANK = 3;

+

+		public Dictionary<uint, GameObject> listBillBoards = new Dictionary<uint, GameObject>();

+

+		private Vector3 localDefaultScale = new Vector3(-0.02f, 0.02f, 0.02f);

+

+		private Action<bool> mSyncDoneCallBack = null;

+

+		private bool mSyncLoading = false;

+

+		private bool mDoneFinish = false;

+

+		private float intertime = 0.5f;

+

+		private LoadCallBack mDragonExpeditionLoadTask = null;

+

+		private Dictionary<int, XDummy> m_AvatarDummys = new Dictionary<int, XDummy>();

+

+		private class DragonExpeditionLoadTask

+		{

+			private DragonCrusadeDlg mDlg;

+

+			public DragonExpeditionLoadTask(DragonCrusadeDlg dlg)

+			{

+				this.mDlg = dlg;

+			}

+

+			public void LoadFinish(UnityEngine.Object obj)

+			{

+				bool flag = this.mDlg != null;

+				if (flag)

+				{

+					this.mDlg.goDragonExpedition = (obj as GameObject);

+					this.mDlg.LoadPrefabSyncDone();

+					this.mDlg = null;

+				}

+			}

+		}

+

+		protected override void OnLoad()

+		{

+			base.OnLoad();

+			this.mDoc = (XSingleton<XGame>.singleton.Doc.GetXComponent(XDragonCrusadeDocument.uuID) as XDragonCrusadeDocument);

+			bool flag = this.mDragonExpeditionLoadTask == null;

+			if (flag)

+			{

+				this.mDragonExpeditionLoadTask = new LoadCallBack(this.LoadFinish);

+			}

+		}

+

+		protected override void Init()

+		{

+			base.Init();

+			base.uiBehaviour.goLoadingTxt.SetText(XStringDefineProxy.GetString("DragonLoadMessage"));

+		}

+

+		private void LoadFinish(UnityEngine.Object obj, object cbOjb)

+		{

+			bool flag = !base.IsLoaded();

+			if (!flag)

+			{

+				this.goDragonExpedition = (obj as GameObject);

+				this.LoadPrefabSyncDone();

+			}

+		}

+

+		public override void RegisterEvent()

+		{

+			base.RegisterEvent();

+			this.m_uiBehaviour.slideSprite.RegisterSpriteDragEventHandler(new SpriteDragEventHandler(this.OnMonsterDrag));

+			this.m_uiBehaviour.slideSprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnMouseClick));

+			base.uiBehaviour.m_Help.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnHelpClicked));

+			this.m_uiBehaviour.m_myRankSpr.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnRankInfo));

+			base.uiBehaviour.m_closed.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnClose));

+			base.uiBehaviour.m_leftBtn.ID = 1UL;

+			base.uiBehaviour.m_rightBtn.ID = 2UL;

+		}

+

+		public bool OnHelpClicked(IXUIButton button)

+		{

+			DlgBase<XCommonHelpTipView, XCommonHelpTipBehaviour>.singleton.ShowHelp(XSysDefine.XSys_DragonCrusade);

+			return true;

+		}

+

+		protected override void OnHide()

+		{

+			base.OnHide();

+			bool flag = this.ixDragonExpedition != null;

+			if (flag)

+			{

+				this.ixDragonExpedition.GetDragonCamera().enabled = false;

+			}

+		}

+

+		protected override void OnShow()

+		{

+			base.OnShow();

+			base.Alloc3DAvatarPool("DragonCrusadeDlg");

+			bool flag = this.ixDragonExpedition != null;

+			if (flag)

+			{

+				this.ixDragonExpedition.GetDragonCamera().enabled = true;

+			}

+		}

+

+		protected override void OnUnload()

+		{

+			this.mDoneFinish = false;

+			this.mSyncLoading = false;

+			bool flag = this._FxFirework != null;

+			if (flag)

+			{

+				XSingleton<XFxMgr>.singleton.DestroyFx(this._FxFirework, true);

+			}

+			this._FxFirework = null;

+			this.DeleteAvatar();

+			this.UnloadPrefab();

+			foreach (KeyValuePair<uint, GameObject> keyValuePair in this.listBillBoards)

+			{

+				XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroy(keyValuePair.Value, true, false);

+			}

+			this.listBillBoards.Clear();

+			base.OnUnload();

+		}

+

+		public override void StackRefresh()

+		{

+			base.StackRefresh();

+			base.Alloc3DAvatarPool("DragonCrusadeDlg");

+			bool flag = this.ixDragonExpedition != null;

+			if (flag)

+			{

+				this.ixDragonExpedition.GetDragonCamera().enabled = true;

+			}

+		}

+

+		public override void OnXNGUIClick(GameObject obj, string path)

+		{

+			base.OnXNGUIClick(obj, path);

+		}

+

+		private void LoadPrefab()

+		{

+		}

+

+		private void UnloadPrefab()

+		{

+			this.ixDragonExpedition = null;

+			XResourceLoaderMgr.SafeDestroy(ref this.goDragonExpedition, true);

+		}

+

+		protected void OnMonsterDrag(IXUIButton button, Vector2 delta)

+		{

+			bool flag = button.ID == 1UL;

+			if (flag)

+			{

+				delta = Vector2.one * (float)Screen.width;

+			}

+			else

+			{

+				delta = Vector2.one * (float)(-(float)Screen.width);

+			}

+			bool flag2 = this.ixDragonExpedition == null;

+			if (!flag2)

+			{

+				this.ixDragonExpedition.Drag(delta.x);

+			}

+		}

+

+		protected bool OnMonsterDrag(Vector2 delta)

+		{

+			bool flag = this.ixDragonExpedition == null;

+			bool result;

+			if (flag)

+			{

+				result = true;

+			}

+			else

+			{

+				this.ixDragonExpedition.Drag(delta.x);

+				result = true;

+			}

+			return result;

+		}

+

+		protected void OnMouseClick(IXUISprite sp)

+		{

+			bool flag = this.ixDragonExpedition == null;

+			if (!flag)

+			{

+				GameObject gameObject = this.ixDragonExpedition.Click();

+				bool flag2 = gameObject != null;

+				if (flag2)

+				{

+					this.OnGateInfo(gameObject.name);

+				}

+			}

+		}

+

+		private bool OnClose(IXUIButton btn)

+		{

+			this.SetVisible(false, true);

+			XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = false;

+			return true;

+		}

+

+		private void OnGateInfo(string gatename)

+		{

+			DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.SetVisibleWithAnimation(true, null);

+			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)

+			{

+				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];

+				bool flag = dragonCrusageGateData.expData.ResName == gatename;

+				if (flag)

+				{

+					DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.SetVisible(true, true);

+					DlgBase<DragonCrusadeGateDlg, DragonCrusadeGateBehavior>.singleton.FreshInfo(dragonCrusageGateData);

+				}

+			}

+		}

+

+		public void OnRankInfo(IXUISprite uiSprite)

+		{

+			DlgBase<DragonCrusadeRankDlg, DragonCrusadeRankBehavior>.singleton.SetVisible(true, true);

+			DlgBase<DragonCrusadeRankDlg, DragonCrusadeRankBehavior>.singleton.RefreshRankWindow(this.mDoc.oResRank);

+		}

+

+		public void RefreshRank(DERankRes oRes)

+		{

+			for (int i = 0; i < 3; i++)

+			{

+				Transform transform = base.uiBehaviour.transform.Find("Bg/MyRank/ScrollView/Tpl" + (i + 1).ToString());

+				IXUILabel ixuilabel = transform.Find("Rank").GetComponent("XUILabel") as IXUILabel;

+				IXUILabel ixuilabel2 = transform.Find("Name").GetComponent("XUILabel") as IXUILabel;

+				IXUILabel ixuilabel3 = transform.Find("Reward").GetComponent("XUILabel") as IXUILabel;

+				IXUISprite ixuisprite = transform.transform.Find("RankImage").GetComponent("XUISprite") as IXUISprite;

+				DERank derank = (i < oRes.ranks.Count) ? oRes.ranks[i] : null;

+				bool flag = derank != null;

+				if (flag)

+				{

+					ixuilabel.SetText("No." + derank.rank);

+					bool flag2 = i < 3;

+					if (flag2)

+					{

+						ixuisprite.SetSprite("N" + (i + 1));

+						ixuisprite.SetVisible(true);

+						ixuilabel.SetVisible(false);

+					}

+					else

+					{

+						ixuisprite.SetVisible(false);

+						ixuilabel.SetVisible(true);

+					}

+					ixuilabel2.SetText(derank.rolename);

+					string text = string.Empty;

+					for (int j = 0; j < derank.reward.Count; j++)

+					{

+						ItemBrief itemBrief = derank.reward[j];

+						ItemList.RowData itemConf = XBagDocument.GetItemConf((int)itemBrief.itemID);

+						text += itemBrief.itemCount.ToString();

+					}

+					ixuilabel3.gameObject.SetActive(true);

+					ixuilabel3.SetText(text);

+				}

+				else

+				{

+					ixuisprite.SetVisible(false);

+					ixuilabel2.SetText("");

+					ixuilabel.SetText("");

+					ixuilabel3.SetText("");

+					ixuilabel3.gameObject.SetActive(false);

+				}

+			}

+			bool flag3 = false;

+			for (int k = 0; k < oRes.ranks.Count; k++)

+			{

+				DERank derank2 = oRes.ranks[k];

+				bool flag4 = derank2.roleID == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;

+				if (flag4)

+				{

+					flag3 = true;

+					base.SetXUILable("Bg/MyRank/My/Rank", derank2.rank.ToString());

+					base.SetXUILable("Bg/MyRank/My/Name", XSingleton<XAttributeMgr>.singleton.XPlayerData.Name);

+					string text2 = string.Empty;

+					for (int l = 0; l < derank2.reward.Count; l++)

+					{

+						ItemBrief itemBrief2 = derank2.reward[l];

+						ItemList.RowData itemConf2 = XBagDocument.GetItemConf((int)itemBrief2.itemID);

+						text2 += itemBrief2.itemCount.ToString();

+					}

+					base.SetXUILable("Bg/MyRank/My/Reward", text2);

+					bool flag5 = k < 3;

+					if (flag5)

+					{

+						base.uiBehaviour.mMyRank.SetActive(false);

+					}

+					break;

+				}

+			}

+			bool flag6 = !flag3;

+			if (flag6)

+			{

+				base.SetXUILable("Bg/MyRank/My/Rank", "");

+				base.SetXUILable("Bg/MyRank/My/Name", "");

+				base.SetXUILable("Bg/MyRank/My/Reward", "");

+			}

+		}

+

+		private void InitData()

+		{

+			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)

+			{

+				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];

+				Transform go = this.ixDragonExpedition.GetGO(dragonCrusageGateData.expData.ResName);

+				bool flag = go == null;

+				if (!flag)

+				{

+					GameObject value = null;

+					bool flag2 = !this.listBillBoards.TryGetValue(dragonCrusageGateData.SceneID, out value);

+					if (flag2)

+					{

+						value = this.RefreshGateEnter(dragonCrusageGateData, go.gameObject);

+						this.listBillBoards.Add(dragonCrusageGateData.SceneID, value);

+					}

+					bool flag3 = XDragonCrusadeDocument.SectonChapterMax[dragonCrusageGateData.Chapter] == dragonCrusageGateData.expData.ChapterID[1];

+					if (flag3)

+					{

+						GameObject gameObject = new GameObject("Snap");

+						gameObject.transform.parent = go.gameObject.transform;

+						bool flag4 = dragonCrusageGateData.expData.SnapPos != null && dragonCrusageGateData.expData.SnapPos.Length == 3;

+						if (flag4)

+						{

+							gameObject.transform.localPosition = new Vector3(dragonCrusageGateData.expData.SnapPos[0], dragonCrusageGateData.expData.SnapPos[1], dragonCrusageGateData.expData.SnapPos[2]);

+						}

+						else

+						{

+							gameObject.transform.localPosition = new Vector3(0.1f, -0.26f, -0.49f);

+						}

+						gameObject.transform.localEulerAngles = new Vector3(0f, 20f, 0f);

+						gameObject.transform.localScale = Vector3.one * 1.5f;

+						IUIDummy snapShot = XSingleton<XUpdater.XUpdater>.singleton.XPlatform.AddComponent(gameObject, EComponentType.EUIDummy) as IUIDummy;

+						this.CreateAvatar(snapShot, dragonCrusageGateData);

+					}

+				}

+			}

+		}

+

+		private void UpdateBillBoard()

+		{

+			foreach (KeyValuePair<uint, GameObject> keyValuePair in this.listBillBoards)

+			{

+				GameObject value = keyValuePair.Value;

+				Vector3 normalized = (value.transform.position - this.ixDragonExpedition.GetDragonCamera().transform.position).normalized;

+				value.transform.rotation *= Quaternion.LookRotation(normalized);

+			}

+		}

+

+		private GameObject RefreshGateEnter(DragonCrusageGateData data, GameObject obj)

+		{

+			uint sceneID = data.SceneID;

+			GameObject gameObject = XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("UI/Billboard/DragonCrusadeBillboard", true, false) as GameObject;

+			XSingleton<UiUtility>.singleton.AddChild(obj, gameObject);

+			gameObject.name = data.SceneID + "_" + data.expData.ResName;

+			gameObject.transform.localScale = this.localDefaultScale;

+			gameObject.transform.position = obj.transform.position;

+			IXUILabel ixuilabel = gameObject.transform.Find("Name").GetComponent("XUILabel") as IXUILabel;

+			ixuilabel.SetText(data.sceneData.Comment);

+			return gameObject;

+		}

+

+		public void RefreshProgressFromNet()

+		{

+			bool flag = !this.mDoneFinish;

+			if (!flag)

+			{

+				this.RefreshProgress();

+			}

+		}

+

+		public void RefreshProgressSync(Action<bool> done)

+		{

+			bool flag = this.ixDragonExpedition != null;

+			if (flag)

+			{

+				bool flag2 = done != null;

+				if (flag2)

+				{

+					done(true);

+				}

+				XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = true;

+			}

+			else

+			{

+				bool flag3 = this.mSyncLoading;

+				if (!flag3)

+				{

+					this.LoadPrefabSync(done);

+				}

+			}

+		}

+

+		private void LoadPrefabSync(Action<bool> done)

+		{

+			base.uiBehaviour.goLoading.SetActive(true);

+			this.mSyncLoading = true;

+			this.mDoneFinish = false;

+			this.mSyncDoneCallBack = done;

+			XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefabAsync("Common/DragonExpedition", this.mDragonExpeditionLoadTask, null, true);

+		}

+

+		public override void OnUpdate()

+		{

+			base.OnUpdate();

+			bool flag = !this.mSyncLoading;

+			if (!flag)

+			{

+				bool flag2 = this.mSyncLoading;

+				if (flag2)

+				{

+				}

+				bool flag3 = this.intertime > 0f;

+				if (flag3)

+				{

+					this.intertime -= Time.deltaTime;

+				}

+				else

+				{

+					this.intertime = 0.5f;

+					bool flag4 = this.mSyncLoading && this.mDoneFinish;

+					if (flag4)

+					{

+						bool flag5 = this.mDragonExpeditionLoadTask != null;

+						if (flag5)

+						{

+							this.mDragonExpeditionLoadTask = null;

+						}

+						base.uiBehaviour.goLoading.SetActive(false);

+						this.mSyncLoading = false;

+					}

+				}

+			}

+		}

+

+		private void LoadPrefabSyncDone()

+		{

+			this.ixDragonExpedition = (this.goDragonExpedition.GetComponent("XDragonExpedition") as IXDragonExpedition);

+			this._FxFirework = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_lzy_gk", null, true);

+			this.InitData();

+			this.RefreshProgress();

+			this.mDoneFinish = true;

+			bool flag = this.mSyncDoneCallBack != null;

+			if (flag)

+			{

+				this.mSyncDoneCallBack(true);

+			}

+			this.mSyncDoneCallBack = null;

+			bool flag2 = this.ixDragonExpedition != null;

+			if (flag2)

+			{

+				this.ixDragonExpedition.GetDragonCamera().enabled = true;

+			}

+			XSingleton<XTutorialHelper>.singleton.DragonCrusadeOpen = true;

+		}

+

+		private void RefreshProgress()

+		{

+			GameObject gameObject = null;

+			for (int i = 0; i < XDragonCrusadeDocument._DragonCrusageGateDataInfo.Count; i++)

+			{

+				DragonCrusageGateData dragonCrusageGateData = XDragonCrusadeDocument._DragonCrusageGateDataInfo[i];

+				DEProgress deProgress = dragonCrusageGateData.deProgress;

+				bool flag = this.listBillBoards.TryGetValue(deProgress.sceneID, out gameObject);

+				if (flag)

+				{

+					Transform transform = gameObject.transform.Find("StageConquered");

+					Transform transform2 = gameObject.transform.Find("BossHP");

+					IXUIProgress ixuiprogress = transform2.GetComponent("XUIProgress") as IXUIProgress;

+					ixuiprogress.value = (float)deProgress.bossavghppercent / 100f;

+					IXUILabel ixuilabel = gameObject.transform.Find("BossHP/Percent").GetComponent("XUILabel") as IXUILabel;

+					ixuilabel.SetText(deProgress.bossavghppercent + "%");

+					switch (dragonCrusageGateData.deProgress.state)

+					{

+					case DEProgressState.DEPS_FINISH:

+					{

+						transform2.localScale = Vector3.zero;

+						transform.gameObject.SetActive(true);

+						this.ixDragonExpedition.SetLimitPos(dragonCrusageGateData.expData.LimitPos);

+						Transform go = this.ixDragonExpedition.GetGO(dragonCrusageGateData.expData.ResName);

+						Renderer component = go.GetComponent<Renderer>();

+						Material sharedMaterial = component.sharedMaterial;

+						component.material = new Material(sharedMaterial)

+						{

+							shader = ShaderManager._transparentGrayMaskRNoLight,

+							renderQueue = 3002

+						};

+						break;

+					}

+					case DEProgressState.DEPS_FIGHT:

+					{

+						this.ixDragonExpedition.SetLimitPos(dragonCrusageGateData.expData.LimitPos);

+						this._FxFirework.Play(gameObject.transform.position, Quaternion.identity, Vector3.one, 1f);

+						transform2.localScale = Vector3.one;

+						transform.gameObject.SetActive(false);

+						bool flag2 = gameObject.transform.parent != null;

+						if (flag2)

+						{

+							this.ixDragonExpedition.Assign(gameObject.transform.parent.localPosition.x);

+						}

+						break;

+					}

+					case DEProgressState.DEPS_NOTOPEN:

+						transform.gameObject.SetActive(false);

+						transform2.localScale = Vector3.zero;

+						break;

+					}

+				}

+				base.SetXUILable("Bg/ChallengeCount/Value", string.Format("{0}/{1}", dragonCrusageGateData.leftcount, dragonCrusageGateData.allcount));

+			}

+		}

+

+		private void CreateAvatar(IUIDummy snapShot, DragonCrusageGateData data)

+		{

+			XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(data.expData.BossID);

+			XEntityPresentation.RowData byPresentID = XSingleton<XEntityMgr>.singleton.EntityInfo.GetByPresentID(byID.PresentID);

+			bool flag = !this.m_AvatarDummys.ContainsKey((int)data.expData.ChapterID[0]);

+			if (flag)

+			{

+				XDummy xdummy = XSingleton<X3DAvatarMgr>.singleton.CreateCommonEntityDummy(this.m_dummPool, byID.PresentID, snapShot, null, 25f);

+				xdummy.Scale = byPresentID.UIAvatarScale;

+				xdummy.EngineObject.SetLocalPRS(Vector3.zero, true, Quaternion.identity, true, Vector3.one * 0.3f, true);

+				this.m_AvatarDummys.Add((int)data.expData.ChapterID[0], xdummy);

+			}

+		}

+

+		private void DeleteAvatar()

+		{

+			base.Return3DAvatarPool();

+			this.m_AvatarDummys.Clear();

+		}

+	}

+}