1 files changed, 392 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XHUDComponent.cs b/Client/Assets/Scripts/XMainClient/XHUDComponent.cs
new file mode 100644
index 00000000..d4d0051b
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/XHUDComponent.cs
@@ -0,0 +1,392 @@
+using System;
+using System.Collections.Generic;
+using UILib;
+using UnityEngine;
+using XMainClient.UI;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+	internal class XHUDComponent : XComponent
+	{
+		public override uint ID
+		{
+			get
+			{
+				return XHUDComponent.uuID;
+			}
+		}
+
+		public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("CombatInfoInScene");
+
+		private GameObject _hudObject = null;
+
+		private List<XHudEntry> _List = new List<XHudEntry>();
+
+		private List<XHudEntry> _Unused = new List<XHudEntry>();
+
+		private Camera gameCamera = null;
+
+		private Camera uiCamera = null;
+
+		private XBattleDocument _BattleDoc;
+
+		public static bool processHud = true;
+
+		private static int currentCount = 0;
+
+		public static int _Max_UI_UpdateCount_PreFrame = 4;
+
+		public static void ResetCurrentCount()
+		{
+			XHUDComponent.currentCount = 0;
+		}
+
+		public override void OnAttachToHost(XObject host)
+		{
+			base.OnAttachToHost(host);
+			this._hudObject = XSingleton<XEngineCommandMgr>.singleton.GetGameObject();
+			this._hudObject.layer = LayerMask.NameToLayer("UI");
+			this._hudObject.name = this._entity.EngineObject.Name + "_hud";
+			this.gameCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
+			this.uiCamera = XSingleton<XGameUI>.singleton.UICamera;
+			XSingleton<UiUtility>.singleton.AddChild(XSingleton<XGameUI>.singleton.UIRoot, this._hudObject.transform);
+			this._BattleDoc = XDocuments.GetSpecificDocument<XBattleDocument>(XBattleDocument.uuID);
+		}
+
+		public override void OnDetachFromHost()
+		{
+			base.OnDetachFromHost();
+			int i = this._List.Count;
+			while (i > 0)
+			{
+				XHudEntry ent = this._List[--i];
+				this.DestroyEntityHudGameObject(ent);
+			}
+			XSingleton<XEngineCommandMgr>.singleton.ReturnGameObject(this._hudObject);
+			this._hudObject = null;
+		}
+
+		protected override void EventSubscribe()
+		{
+			base.RegisterEvent(XEventDefine.XEvent_HUDAdd, new XComponent.XEventHandler(this.AddHud));
+			base.RegisterEvent(XEventDefine.XEvent_HUDDoodad, new XComponent.XEventHandler(this.AddDoodadHUD));
+		}
+
+		private XHudEntry CreateHUD()
+		{
+			bool flag = this._Unused.Count > 0;
+			XHudEntry result;
+			if (flag)
+			{
+				XHudEntry xhudEntry = this._Unused[this._Unused.Count - 1];
+				this._Unused.RemoveAt(this._Unused.Count - 1);
+				xhudEntry.time = Time.realtimeSinceStartup;
+				xhudEntry.offset = 0f;
+				this._List.Add(xhudEntry);
+				result = xhudEntry;
+			}
+			else
+			{
+				XHudEntry xhudEntry2 = new XHudEntry();
+				this._List.Add(xhudEntry2);
+				result = xhudEntry2;
+			}
+			return result;
+		}
+
+		public bool AddDoodadHUD(XEventArgs e)
+		{
+			XHUDDoodadArgs xhuddoodadArgs = e as XHUDDoodadArgs;
+			GameObject gameObject = XSingleton<XResourceLoaderMgr>.singleton.CreateFromPrefab("UI/Billboard/HUDDoodad", Vector3.zero, Quaternion.identity, true, false);
+			gameObject.layer = LayerMask.NameToLayer("UI");
+			XSingleton<UiUtility>.singleton.AddChild(this._hudObject, gameObject);
+			XHudEntry xhudEntry = this.CreateHUD();
+			xhudEntry.time = Time.realtimeSinceStartup;
+			xhudEntry.stay = 0.1f;
+			xhudEntry.offset = 0f;
+			xhudEntry.val = 0f;
+			xhudEntry.label = (gameObject.transform.GetComponent("XUILabel") as IXUILabel);
+			xhudEntry.label.SetRootAsUIPanel(true);
+			xhudEntry.isDigital = true;
+			IXUILabelSymbol ixuilabelSymbol = gameObject.transform.GetComponent("XUILabelSymbol") as IXUILabelSymbol;
+			ItemList.RowData itemConf = XBagDocument.GetItemConf(xhuddoodadArgs.itemid);
+			bool flag = itemConf != null;
+			if (flag)
+			{
+				ItemType itemType = (ItemType)itemConf.ItemType;
+				if (itemType != ItemType.VIRTUAL_ITEM)
+				{
+					ItemList.RowData itemConf2 = XBagDocument.GetItemConf(xhuddoodadArgs.itemid);
+					string itemQualityColorStr = XSingleton<UiUtility>.singleton.GetItemQualityColorStr((int)itemConf2.ItemQuality);
+					ixuilabelSymbol.InputText = string.Format("[{0}]{1}[-] x{2}", itemQualityColorStr, XSingleton<UiUtility>.singleton.ChooseProfString(itemConf2.ItemName, 0u), xhuddoodadArgs.count);
+				}
+				else
+				{
+					string inputText = XLabelSymbolHelper.FormatCostWithIcon("+{1} {0}", xhuddoodadArgs.count, (ItemEnum)xhuddoodadArgs.itemid);
+					ixuilabelSymbol.InputText = inputText;
+				}
+			}
+			this.UIFollowTarget();
+			IXHUDDescription ixhuddescription = gameObject.transform.GetComponent("HUDDescription") as IXHUDDescription;
+			xhudEntry.offsetCurve = ixhuddescription.GetPosCurve();
+			xhudEntry.scaleCurve = ixhuddescription.GetScaleCurve();
+			xhudEntry.alphaCurve = ixhuddescription.GetAlphaCurve();
+			return true;
+		}
+
+		public bool AddHud(XEventArgs e)
+		{
+			bool flag = !XHUDComponent.processHud || XHUDComponent.currentCount > XHUDComponent._Max_UI_UpdateCount_PreFrame;
+			bool result;
+			if (flag)
+			{
+				e.Recycle();
+				result = true;
+			}
+			else
+			{
+				bool flag2 = !XHUDComponent.processHud;
+				if (flag2)
+				{
+					result = true;
+				}
+				else
+				{
+					bool flag3 = XHUDComponent.currentCount >= XHUDComponent._Max_UI_UpdateCount_PreFrame;
+					if (flag3)
+					{
+						bool flag4 = this._List.Count > 0;
+						if (flag4)
+						{
+							this.DeleteHUD(this._List[0]);
+						}
+					}
+					XHUDAddEventArgs xhudaddEventArgs = e as XHUDAddEventArgs;
+					bool flag5 = !this._entity.IsPlayer && (!XSingleton<XScene>.singleton.bSpectator || XSingleton<XEntityMgr>.singleton.Player.WatchTo == null || XSingleton<XEntityMgr>.singleton.Player.WatchTo.ID != this._entity.ID);
+					if (flag5)
+					{
+						ulong num = 0UL;
+						bool flag6 = false;
+						bool flag7 = xhudaddEventArgs.caster == null || xhudaddEventArgs.caster.Attributes == null || xhudaddEventArgs.caster.Attributes.HostID == 0UL;
+						if (flag7)
+						{
+							bool flag8 = !this._BattleDoc.ShowTeamMemberDamageHUD;
+							if (flag8)
+							{
+								num = xhudaddEventArgs.damageResult.Caster;
+							}
+							else
+							{
+								flag6 = true;
+							}
+						}
+						else
+						{
+							bool showMobDamageHUD = this._BattleDoc.ShowMobDamageHUD;
+							if (!showMobDamageHUD)
+							{
+								return true;
+							}
+							num = xhudaddEventArgs.caster.Attributes.HostID;
+						}
+						bool flag9 = !flag6;
+						if (flag9)
+						{
+							bool flag10 = num > 0UL;
+							if (!flag10)
+							{
+								return true;
+							}
+							bool flag11 = XSingleton<XEntityMgr>.singleton.Player.WatchTo != null && XSingleton<XEntityMgr>.singleton.Player.WatchTo.ID == num;
+							bool flag12 = num != XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID && !flag11;
+							if (flag12)
+							{
+								return true;
+							}
+						}
+					}
+					GameObject hudtemplateByDamageResult = XSingleton<XCombatHUDMgr>.singleton.GetHUDTemplateByDamageResult(xhudaddEventArgs.damageResult, this._entity.IsPlayer);
+					XHUDComponent.currentCount++;
+					hudtemplateByDamageResult.layer = LayerMask.NameToLayer("UI");
+					XHudEntry xhudEntry = this.CreateHUD();
+					xhudEntry.time = Time.realtimeSinceStartup;
+					xhudEntry.stay = 0.1f;
+					xhudEntry.offset = 0f;
+					xhudEntry.val = (float)xhudaddEventArgs.damageResult.Value;
+					bool flag13 = !xhudEntry.init;
+					if (flag13)
+					{
+						xhudEntry.label = (hudtemplateByDamageResult.transform.GetComponent("XUILabel") as IXUILabel);
+						xhudEntry.label.SetRootAsUIPanel(true);
+					}
+					XSingleton<UiUtility>.singleton.AddChildNoMark(this._hudObject, hudtemplateByDamageResult);
+					xhudEntry.isDigital = true;
+					string text = XSingleton<XCombatHUDMgr>.singleton.GetHUDText(xhudaddEventArgs.damageResult, xhudEntry.isDigital);
+					bool isMainViewEntity = this._entity.IsMainViewEntity;
+					if (isMainViewEntity)
+					{
+						text = ((xhudaddEventArgs.damageResult.Value >= 0.0) ? "-" : "+") + text;
+					}
+					bool flag14 = xhudaddEventArgs.damageResult.Result != ProjectResultType.PJRES_IMMORTAL && xhudaddEventArgs.damageResult.Result != ProjectResultType.PJRES_MISS;
+					if (flag14)
+					{
+						xhudEntry.label.SetText(text);
+					}
+					bool flag15 = this._entity.IsEnemy && xhudaddEventArgs.damageResult.Value > 0.0;
+					if (flag15)
+					{
+						XSingleton<XLevelStatistics>.singleton.ls._total_damage += (float)xhudaddEventArgs.damageResult.Value;
+					}
+					else
+					{
+						bool isPlayer = this._entity.IsPlayer;
+						if (isPlayer)
+						{
+							bool flag16 = xhudaddEventArgs.damageResult.Value > 0.0;
+							if (flag16)
+							{
+								XSingleton<XLevelStatistics>.singleton.ls._total_hurt += (float)xhudaddEventArgs.damageResult.Value;
+							}
+							else
+							{
+								XSingleton<XLevelStatistics>.singleton.ls._total_heal += (float)(-(float)xhudaddEventArgs.damageResult.Value);
+							}
+						}
+					}
+					bool flag17 = !xhudaddEventArgs.damageResult.IsCritical() && !this._entity.IsMainViewEntity;
+					if (flag17)
+					{
+						bool bEnable = false;
+						Color white = Color.white;
+						Color white2 = Color.white;
+						XSingleton<XCombatHUDMgr>.singleton.GetElementColor(xhudaddEventArgs.damageResult.ElementType, ref bEnable, ref white, ref white2);
+						xhudEntry.label.SetGradient(bEnable, white, white2);
+						xhudEntry.label.SetColor(white);
+					}
+					bool flag18 = !xhudaddEventArgs.damageResult.IsCritical() && xhudaddEventArgs.damageResult.Result != ProjectResultType.PJRES_IMMORTAL && this._entity.IsMainViewEntity;
+					if (flag18)
+					{
+						xhudEntry.label.SetGradient(false, Color.white, Color.white);
+						xhudEntry.label.SetColor(new Color32(byte.MaxValue, 32, 73, byte.MaxValue));
+					}
+					bool flag19 = xhudaddEventArgs.damageResult.Value < 0.0;
+					if (flag19)
+					{
+						Color green = Color.green;
+						Color green2 = Color.green;
+						xhudEntry.label.SetGradient(true, green, green2);
+						xhudEntry.label.SetColor(green);
+					}
+					this.UIFollowTarget();
+					bool flag20 = !xhudEntry.init;
+					if (flag20)
+					{
+						IXHUDDescription ixhuddescription = hudtemplateByDamageResult.transform.GetComponent("HUDDescription") as IXHUDDescription;
+						xhudEntry.offsetCurve = ixhuddescription.GetPosCurve();
+						xhudEntry.alphaCurve = ixhuddescription.GetAlphaCurve();
+						xhudEntry.scaleCurve = ixhuddescription.GetScaleCurve();
+					}
+					result = true;
+				}
+			}
+			return result;
+		}
+
+		private void DeleteHUD(XHudEntry ent)
+		{
+			this._List.Remove(ent);
+			this._Unused.Add(ent);
+			this.DestroyEntityHudGameObject(ent);
+			XHUDComponent.currentCount--;
+		}
+
+		protected void HideEntityHudGameObject(XHudEntry ent)
+		{
+			ent.label.gameObject.transform.localPosition = XResourceLoaderMgr.Far_Far_Away;
+			XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroy(ent.label.gameObject, true, false);
+		}
+
+		protected void DestroyEntityHudGameObject(XHudEntry ent)
+		{
+			ent.label.gameObject.transform.localPosition = XResourceLoaderMgr.Far_Far_Away;
+			XSingleton<XResourceLoaderMgr>.singleton.UnSafeDestroy(ent.label.gameObject, true, false);
+		}
+
+		private void UIFollowTarget()
+		{
+			bool flag = this.gameCamera == null;
+			if (flag)
+			{
+				this.gameCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
+			}
+			float height = this._entity.Height;
+			Vector3 radiusCenter = this._entity.RadiusCenter;
+			Vector3 vector;
+			vector= new Vector3(radiusCenter.x, radiusCenter.y + height, radiusCenter.z);
+			Vector3 vector2 = this.gameCamera.WorldToViewportPoint(vector);
+			if (vector2.z > 0f)
+			{
+				bool flag2 = vector2.x > 0f && vector2.x < 1f && vector2.y > 0f && vector2.y < 1f;
+			}
+			this._hudObject.transform.position = this.uiCamera.ViewportToWorldPoint(vector2);
+			vector2 = this._hudObject.transform.localPosition;
+			vector2.x = (float)Mathf.FloorToInt(vector2.x);
+			vector2.y = (float)Mathf.FloorToInt(vector2.y);
+			bool flag3 = vector2.y > (float)(XSingleton<XGameUI>.singleton.Base_UI_Height / 2) * 0.5f;
+			if (flag3)
+			{
+				vector2.y = (float)(XSingleton<XGameUI>.singleton.Base_UI_Height / 2) * 0.5f;
+			}
+			vector2.z = 0f;
+			this._hudObject.transform.localPosition = vector2;
+		}
+
+		private void UpdateHUDs()
+		{
+			float realtimeSinceStartup = Time.realtimeSinceStartup;
+			int i = this._List.Count;
+			while (i > 0)
+			{
+				XHudEntry xhudEntry = this._List[--i];
+				float time = xhudEntry.offsetCurve[xhudEntry.offsetCurve.length - 1].time;
+				float time2 = xhudEntry.scaleCurve[xhudEntry.scaleCurve.length - 1].time;
+				float time3 = xhudEntry.alphaCurve[xhudEntry.alphaCurve.length - 1].time;
+				float num = Mathf.Max(Mathf.Max(time2, time), time3);
+				float num2 = realtimeSinceStartup - xhudEntry.movementStart;
+				xhudEntry.offset = xhudEntry.offsetCurve.Evaluate(num2);
+				float num3 = xhudEntry.scaleCurve.Evaluate(realtimeSinceStartup - xhudEntry.time);
+				bool flag = num3 < 0.001f;
+				if (flag)
+				{
+					num3 = 0.001f;
+				}
+				xhudEntry.label.gameObject.transform.localScale = Vector3.one * num3;
+				float num4 = xhudEntry.alphaCurve.Evaluate(realtimeSinceStartup - xhudEntry.time);
+				Color color = xhudEntry.label.GetColor();
+				Color color2;
+				color2= new Color(color.r, color.g, color.b, num4);
+				xhudEntry.label.SetColor(color2);
+				bool flag2 = num2 > num;
+				if (flag2)
+				{
+					this.DeleteHUD(xhudEntry);
+				}
+			}
+			float num5 = -200f;
+			int j = this._List.Count;
+			while (j > 0)
+			{
+				XHudEntry xhudEntry2 = this._List[--j];
+				num5 = Mathf.Max(num5, xhudEntry2.offset);
+				xhudEntry2.label.gameObject.transform.localPosition = new Vector3(0f, num5, 0f);
+				num5 += Mathf.Round(xhudEntry2.label.gameObject.transform.localScale.y * 20f);
+			}
+		}
+
+		public override void PostUpdate(float fDeltaT)
+		{
+			this.UpdateHUDs();
+		}
+	}
+}