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

namespace XMainClient.UI
{
	internal class BattleIndicateHandler : DlgHandlerBase
	{
		public XUIPool m_TeamIndicatePool = new XUIPool(XSingleton<XGameUI>.singleton.m_uiTool);

		public Transform m_Direction;

		private Vector3 m_DirectPos;

		private Transform m_CachedDirectionTarget;

		private List<BattleIndicator> m_IndicatesList = new List<BattleIndicator>();

		private Dictionary<ulong, BattleIndicator> m_EntityIndicates = new Dictionary<ulong, BattleIndicator>();

		private float _Half_H_Fov;

		private float _tan_half_H_fov;

		private float _Half_V_Fov;

		private float _tan_half_V_fov;

		private float _sqr_tan_half_V_fov;

		private Transform m_MiniMapRotation;

		private IXUITexture m_MiniMap;

		private Transform m_MiniMapCamera;

		private XUIPool m_MiniMapElementPool = new XUIPool(XSingleton<XGameUI>.singleton.m_uiTool);

		private Dictionary<ulong, MiniMapElement> m_MiniMapElements = new Dictionary<ulong, MiniMapElement>();

		private List<MiniMapElement> m_MiniMapDoor = new List<MiniMapElement>();

		private List<MiniMapElement> m_MiniMapBuff = new List<MiniMapElement>();

		private Dictionary<ulong, MiniMapElement> m_MiniMapDoodadDic = new Dictionary<ulong, MiniMapElement>();

		private List<MiniMapElement> m_MiniMapFx = new List<MiniMapElement>();

		private Dictionary<ulong, MiniMapElement> m_MiniMapFxDic = new Dictionary<ulong, MiniMapElement>();

		private List<MiniMapElement> m_MiniMapPic = new List<MiniMapElement>();

		private Dictionary<ulong, MiniMapElement> m_MiniMapPicDic = new Dictionary<ulong, MiniMapElement>();

		private uint m_MiniMapFxToken = 0u;

		private uint m_MiniMapPicToken = 0u;

		private float MiniMapScale;

		private bool _staticMap;

		private Vector3 _referencePos;

		private Vector2 _outSize = Vector2.one;

		private int _heroBattleDepth_O;

		private int _heroBattleDepth_A;

		private static bool _hide_minimap_opponent;

		private XEntity _campEntity;

		private List<ulong> _unInitEntityList = new List<ulong>();

		private Vector2 MiniMapSize;

		private readonly float BASESIZE = 65f;

		private Vector2 MapSizeInTable;

		private int MaxDisplayNum = 0;

		private List<int> m_ShouldShowEnemyIndex = new List<int>();

		private HashSet<ulong> m_ValidSet = new HashSet<ulong>();

		protected override void Init()
		{
			base.Init();
			this._campEntity = XSingleton<XEntityMgr>.singleton.Player;
			bool flag = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
			if (flag)
			{
				this.InitTeamIndicate();
			}
			this.MiniMapSize = new Vector2(this.BASESIZE, this.BASESIZE);
			this._staticMap = XSingleton<XSceneMgr>.singleton.GetSceneStaticMiniMapCenter(XSingleton<XScene>.singleton.SceneID, out this._referencePos);
			this._outSize = Vector2.one;
			this.SetMiniMapSize(XSingleton<XSceneMgr>.singleton.GetSceneMiniMapOutSize(XSingleton<XScene>.singleton.SceneID), 0f);
			this.InitMiniMap();
			this._heroBattleDepth_O = 200;
			this._heroBattleDepth_A = 100;
			this.MaxDisplayNum = XSingleton<XGlobalConfig>.singleton.GetInt("MaxEnmeyIndicatorDisplayNum");
		}

		public void SetMiniMapSize(Vector2 size, float scale = 0f)
		{
			bool flag = size != this._outSize;
			if (flag)
			{
				this.SetMiniMapOutSize(Vector2.one);
				this.SetMiniMapOutSize(size);
			}
			bool flag2 = scale > 0f;
			if (flag2)
			{
				this.MiniMapScale = scale;
			}
		}

		private void SetMiniMapOutSize(Vector2 size)
		{
			Vector2 outSize = this._outSize;
			this._outSize = size;
			this.MiniMapSize = new Vector2(this.BASESIZE * this._outSize.x, this.BASESIZE * this._outSize.y);
			IXUISprite ixuisprite = base.PanelObject.transform.Find("Bg/MapBg").GetComponent("XUISprite") as IXUISprite;
			ixuisprite.spriteWidth = (int)((float)ixuisprite.spriteWidth / outSize.x * this._outSize.x);
			ixuisprite.spriteHeight = (int)((float)ixuisprite.spriteHeight / outSize.y * this._outSize.y);
			IXUIPanel ixuipanel = base.PanelObject.transform.Find("MiniMap").GetComponent("XUIPanel") as IXUIPanel;
			Vector4 clipRange = ixuipanel.ClipRange;
			float num = clipRange.z;
			clipRange.z = clipRange.z / outSize.x * this._outSize.x;
			clipRange.x = -(clipRange.z - num) / 2f;
			num = clipRange.w;
			clipRange.w = clipRange.w / outSize.y * this._outSize.y;
			clipRange.y = -(clipRange.w - num) / 2f;
			ixuipanel.ClipRange = clipRange;
			IXUISprite ixuisprite2 = base.PanelObject.transform.Find("MiniMap/Bg").GetComponent("XUISprite") as IXUISprite;
			Vector3 localPosition = ixuisprite2.transform.localPosition;
			num = (float)ixuisprite2.spriteWidth;
			ixuisprite2.spriteWidth = (int)((float)ixuisprite2.spriteWidth / outSize.x * this._outSize.x);
			localPosition.x = -((float)ixuisprite2.spriteWidth - num) / 2f;
			num = (float)ixuisprite2.spriteHeight;
			ixuisprite2.spriteHeight = (int)((float)ixuisprite2.spriteHeight / outSize.y * this._outSize.y);
			localPosition.y = -((float)ixuisprite2.spriteHeight - num) / 2f;
			ixuisprite2.transform.localPosition = localPosition;
			IXUISprite ixuisprite3 = base.PanelObject.transform.Find("Bg/NameBg").GetComponent("XUISprite") as IXUISprite;
			num = (float)ixuisprite3.spriteWidth;
			ixuisprite3.spriteWidth = (int)((float)ixuisprite3.spriteWidth / outSize.x * this._outSize.x);
			localPosition = ixuisprite3.transform.localPosition;
			ixuisprite3.transform.localPosition = new Vector3(-((float)ixuisprite3.spriteWidth - num) / 2f, localPosition.y);
			IXUILabel ixuilabel = base.PanelObject.transform.Find("Bg/Name").GetComponent("XUILabel") as IXUILabel;
			num = (float)ixuilabel.spriteWidth;
			ixuilabel.spriteWidth = (int)((float)ixuilabel.spriteWidth / outSize.x * this._outSize.x);
			localPosition = ixuilabel.gameObject.transform.localPosition;
			ixuilabel.gameObject.transform.localPosition = new Vector3(-((float)ixuilabel.spriteWidth - num) / 2f, localPosition.y);
		}

		public override void OnUnload()
		{
			foreach (MiniMapElement miniMapElement in this.m_MiniMapElements.Values)
			{
				this.DestroyFx(miniMapElement.notice);
			}
			foreach (MiniMapElement miniMapElement2 in this.m_MiniMapDoodadDic.Values)
			{
				this.DestroyFx(miniMapElement2.notice);
			}
			foreach (MiniMapElement miniMapElement3 in this.m_MiniMapFxDic.Values)
			{
				this.DestroyFx(miniMapElement3.notice);
			}
			foreach (MiniMapElement miniMapElement4 in this.m_MiniMapPicDic.Values)
			{
				this.DestroyFx(miniMapElement4.notice);
			}
			this.m_MiniMapDoor.Clear();
			this.m_MiniMapElements.Clear();
			this.m_MiniMapBuff.Clear();
			this.m_MiniMapDoodadDic.Clear();
			this.m_MiniMapFx.Clear();
			this.m_MiniMapPic.Clear();
			this.m_MiniMapFxDic.Clear();
			this.m_MiniMapPicDic.Clear();
			this.m_MiniMapElementPool.ReturnAll(false);
			this.m_MiniMap.SetTexturePath("");
			base.OnUnload();
		}

		private void InitTeamIndicate()
		{
			this._Half_V_Fov = 0.0174532924f * (XSingleton<XScene>.singleton.GameCamera.UnityCamera.fieldOfView * 0.5f);
			float num = (float)XSingleton<XGameUI>.singleton.Base_UI_Width / (float)XSingleton<XGameUI>.singleton.Base_UI_Height;
			this._Half_H_Fov = (float)Math.Atan(Math.Tan((double)this._Half_V_Fov) * (double)num) * 0.95f;
			this._tan_half_H_fov = (float)Math.Tan((double)this._Half_H_Fov);
			this._tan_half_V_fov = (float)Math.Tan((double)this._Half_V_Fov);
			this._sqr_tan_half_V_fov = this._tan_half_V_fov * this._tan_half_V_fov;
			Transform transform = base.PanelObject.transform.Find("EnemyIndicate");
			this.m_TeamIndicatePool.SetupPool(transform.parent.gameObject, transform.gameObject, 10u, true);
			this.m_Direction = base.PanelObject.transform.Find("Direction");
			this.m_DirectPos = this.m_Direction.localPosition;
			this.m_Direction.gameObject.transform.localPosition = XGameUI.Far_Far_Away;
			this.m_EntityIndicates.Clear();
			this.m_IndicatesList.Clear();
			this.m_TeamIndicatePool.ReturnAll(false);
		}

		private void InitMiniMap()
		{
			this.m_MiniMapCamera = base.PanelObject.transform.Find("MiniMap/Bg/Rotation/Camera");
			this.m_MiniMapCamera.gameObject.SetActive(!this._staticMap);
			Transform transform = base.PanelObject.transform.Find("MiniMap/Bg/Rotation/Element");
			this.m_MiniMapElementPool.SetupPool(transform.parent.gameObject, transform.gameObject, 20u, true);
			this.m_MiniMapRotation = base.PanelObject.transform.Find("MiniMap/Bg/Rotation");
			this.m_MiniMap = (base.PanelObject.transform.Find("MiniMap/Bg/Rotation/Map").GetComponent("XUITexture") as IXUITexture);
			this.MiniMapScale = (float)XSingleton<XGlobalConfig>.singleton.GetInt("MiniMapScale") / 10f;
			this.MiniMapInit();
		}

		private void MiniMapInit()
		{
			this.m_MiniMapDoor.Clear();
			this.m_MiniMapElements.Clear();
			this.m_MiniMapBuff.Clear();
			this.m_MiniMapDoodadDic.Clear();
			this.m_MiniMapFx.Clear();
			this.m_MiniMapPic.Clear();
			this.m_MiniMapFxDic.Clear();
			this.m_MiniMapPicDic.Clear();
			this.m_MiniMapElementPool.ReturnAll(false);
			this.MiniMapAdd(XSingleton<XEntityMgr>.singleton.Player);
			uint sceneID = XSingleton<XScene>.singleton.SceneID;
			string sceneMiniMap = XSingleton<XSceneMgr>.singleton.GetSceneMiniMap(sceneID);
			bool flag = !string.IsNullOrEmpty(sceneMiniMap);
			if (flag)
			{
				this.m_MiniMap.SetTexturePath("atlas/UI/Battle/minimap/" + sceneMiniMap);
			}
			short[] sceneMiniMapSize = XSingleton<XSceneMgr>.singleton.GetSceneMiniMapSize(sceneID);
			bool flag2 = sceneMiniMapSize != null;
			if (flag2)
			{
				bool flag3 = sceneMiniMapSize.Length > 2;
				if (flag3)
				{
					this.MiniMapScale = (float)sceneMiniMapSize[2] / 10f;
				}
				this.MapSizeInTable = new Vector2((float)sceneMiniMapSize[0], (float)sceneMiniMapSize[1]);
				this.m_MiniMap.spriteWidth = (int)(this.MapSizeInTable.x * this.MiniMapScale);
				this.m_MiniMap.spriteHeight = (int)(this.MapSizeInTable.y * this.MiniMapScale);
			}
			this.m_MiniMapRotation.transform.eulerAngles = new Vector3(0f, 0f, (float)XSingleton<XSceneMgr>.singleton.GetSceneMiniMapRotation(sceneID));
			BattleIndicateHandler._hide_minimap_opponent = false;
		}

		public void SetMiniMapRotation(float rotation)
		{
			bool flag = XSingleton<XSceneMgr>.singleton.GetSceneMiniMapRotation(XSingleton<XScene>.singleton.SceneID) < 0;
			if (flag)
			{
				bool flag2 = this.m_MiniMapRotation != null;
				if (flag2)
				{
					this.m_MiniMapRotation.transform.eulerAngles = new Vector3(0f, 0f, rotation);
				}
			}
		}

		public override void OnUpdate()
		{
			base.OnUpdate();
			bool flag = XSingleton<XEntityMgr>.singleton.Player == null;
			if (!flag)
			{
				bool flag2 = !this._staticMap;
				if (flag2)
				{
					this._referencePos = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position;
				}
				bool flag3 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.IsLoaded();
				if (flag3)
				{
					this.m_ValidSet.Clear();
					this.UpdateTeamIndicate();
					this.UpdateEnemyIndicate();
					this.UpdateDirection();
					bool flag4 = this.m_IndicatesList.Count != this.m_ValidSet.Count;
					if (flag4)
					{
						for (int i = this.m_IndicatesList.Count - 1; i >= 0; i--)
						{
							bool flag5 = !this.m_ValidSet.Contains(this.m_IndicatesList[i].id);
							if (flag5)
							{
								BattleIndicator battleIndicator = this.m_IndicatesList[i];
								this.m_TeamIndicatePool.ReturnInstance(battleIndicator.sp.gameObject, false);
								this.m_EntityIndicates.Remove(battleIndicator.id);
								this.m_IndicatesList.RemoveAt(i);
							}
						}
					}
				}
				this.UpdateMiniMap();
			}
		}

		private void UpdateMiniMap()
		{
			bool flag = this._campEntity == null;
			if (!flag)
			{
				this.m_MiniMap.spriteWidth = (int)(this.MapSizeInTable.x * this.MiniMapScale);
				this.m_MiniMap.spriteHeight = (int)(this.MapSizeInTable.y * this.MiniMapScale);
				MiniMapElement element;
				bool flag2 = this.m_MiniMapElements.TryGetValue(this._campEntity.ID, out element);
				if (flag2)
				{
					this.SetupMiniMapElement(this._campEntity, element, false);
					this.m_MiniMap.gameObject.transform.localPosition = new Vector3(-this._referencePos.x, -this._referencePos.z) * this.MiniMapScale;
				}
				bool flag3 = !this._staticMap && this.m_MiniMapCamera != null && XSingleton<XScene>.singleton.GameCamera.UnityCamera != null;
				if (flag3)
				{
					this.m_MiniMapCamera.localEulerAngles = new Vector3(0f, 0f, -XSingleton<XScene>.singleton.GameCamera.UnityCamera.transform.eulerAngles.y);
				}
				List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._campEntity);
				for (int i = 0; i < opponent.Count; i++)
				{
					bool flag4 = this.m_MiniMapElements.TryGetValue(opponent[i].ID, out element);
					if (flag4)
					{
						this.SetupMiniMapElement(opponent[i], element, BattleIndicateHandler._hide_minimap_opponent || !opponent[i].IsVisible);
					}
				}
				List<XEntity> ally = XSingleton<XEntityMgr>.singleton.GetAlly(this._campEntity);
				for (int j = 0; j < ally.Count; j++)
				{
					bool flag5 = this.m_MiniMapElements.TryGetValue(ally[j].ID, out element);
					if (flag5)
					{
						this.SetupMiniMapElement(ally[j], element, false);
					}
				}
				for (int k = 0; k < this.m_MiniMapDoor.Count; k++)
				{
					this.SetupMiniMapStatic(this.m_MiniMapDoor[k]);
				}
				for (int l = 0; l < this.m_MiniMapBuff.Count; l++)
				{
					this.SetupMiniMapStatic(this.m_MiniMapBuff[l]);
				}
				for (int m = 0; m < this.m_MiniMapFx.Count; m++)
				{
					this.SetupMiniMapFxStatic(this.m_MiniMapFx[m]);
				}
				for (int n = 0; n < this.m_MiniMapPic.Count; n++)
				{
					this.SetupMiniMapFxStatic(this.m_MiniMapPic[n]);
				}
			}
		}

		private void SetupMiniMapElement(XEntity entity, MiniMapElement element, bool hide = false)
		{
			bool deprecated = entity.Deprecated;
			if (deprecated)
			{
				this.m_MiniMapElements.Remove(entity.ID);
				this.DestroyFx(element.notice);
				element.notice = null;
				this.m_MiniMapElementPool.ReturnInstance(element.sp.gameObject, false);
			}
			else
			{
				Vector3 position = entity.EngineObject.Position;
				float num = position.x - this._referencePos.x;
				float num2 = position.z - this._referencePos.z;
				element.transform.localPosition = new Vector3(num, num2) * this.MiniMapScale;
				element.transform.parent = element.transform.parent.parent;
				bool flag = element.transform.localPosition.x > this.MiniMapSize.x;
				if (flag)
				{
					num = this.MiniMapSize.x;
				}
				else
				{
					bool flag2 = element.transform.localPosition.x < -this.MiniMapSize.x;
					if (flag2)
					{
						num = -this.MiniMapSize.x;
					}
					else
					{
						num = element.transform.localPosition.x;
					}
				}
				bool flag3 = element.transform.localPosition.y > this.MiniMapSize.y;
				if (flag3)
				{
					num2 = this.MiniMapSize.y;
				}
				else
				{
					bool flag4 = element.transform.localPosition.y < -this.MiniMapSize.y;
					if (flag4)
					{
						num2 = -this.MiniMapSize.y;
					}
					else
					{
						num2 = element.transform.localPosition.y;
					}
				}
				element.transform.localPosition = new Vector3(num, num2);
				element.transform.parent = this.m_MiniMapRotation;
				element.sp.transform.localEulerAngles = -this.m_MiniMapRotation.transform.eulerAngles;
				float alpha = 1f;
				bool isPlayer = entity.IsPlayer;
				if (!isPlayer)
				{
					bool isDead = entity.IsDead;
					if (isDead)
					{
						alpha = 0f;
					}
				}
				if (hide)
				{
					alpha = 0f;
				}
				element.sp.SetAlpha(alpha);
			}
		}

		private void SetupMiniMapStatic(MiniMapElement element)
		{
			element.sp.transform.localPosition = new Vector3(element.transform.position.x - this._referencePos.x, element.transform.position.z - this._referencePos.z) * this.MiniMapScale;
			element.sp.transform.localEulerAngles = -this.m_MiniMapRotation.transform.eulerAngles;
		}

		private void SetupMiniMapFxStatic(MiniMapElement element)
		{
			element.sp.transform.localPosition = new Vector3(element.pos.x - this._referencePos.x, element.pos.z - this._referencePos.z) * this.MiniMapScale;
		}

		private void SetupMiniMapPicStatic(MiniMapElement element)
		{
			element.sp.transform.localPosition = new Vector3(element.pos.x - this._referencePos.x, element.pos.z - this._referencePos.z) * this.MiniMapScale;
		}

		public void DelTeamIndicate(ulong uid)
		{
			BattleIndicator battleIndicator;
			bool flag = this.m_EntityIndicates.TryGetValue(uid, out battleIndicator);
			if (flag)
			{
				this.m_TeamIndicatePool.ReturnInstance(battleIndicator.sp.gameObject, false);
				this.m_EntityIndicates.Remove(uid);
				this.m_IndicatesList.Remove(battleIndicator);
			}
		}

		protected void UpdateTeamIndicate()
		{
			bool flag = XSingleton<XScene>.singleton.SceneData == null || XSingleton<XScene>.singleton.SceneData.HideTeamIndicate;
			if (!flag)
			{
				List<XEntity> ally = XSingleton<XEntityMgr>.singleton.GetAlly(this._campEntity);
				for (int i = 0; i < ally.Count; i++)
				{
					bool flag2 = ally[i] == XSingleton<XEntityMgr>.singleton.Player;
					if (!flag2)
					{
						bool flag3 = !ally[i].IsRole;
						if (!flag3)
						{
							BattleIndicator bi;
							bool flag4 = !this.m_EntityIndicates.TryGetValue(ally[i].ID, out bi);
							if (flag4)
							{
								this.CreateEntityIndicate(out bi, ally[i], true);
							}
							bool flag5 = !XEntity.ValideEntity(ally[i]);
							if (!flag5)
							{
								this.m_ValidSet.Add(ally[i].ID);
								this.ShowIndicatePosition(bi, ally[i], true);
							}
						}
					}
				}
			}
		}

		protected void UpdateEnemyIndicate()
		{
			List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._campEntity);
			this.m_ShouldShowEnemyIndex.Clear();
			for (int i = 0; i < opponent.Count; i++)
			{
				bool flag = !opponent[i].IsEnemy;
				if (!flag)
				{
					bool isPuppet = opponent[i].IsPuppet;
					if (!isPuppet)
					{
						bool flag2 = XSingleton<XGame>.singleton.SyncMode && !opponent[i].IsServerFighting;
						if (!flag2)
						{
							bool flag3 = !XSingleton<XGame>.singleton.SyncMode && !opponent[i].IsFighting;
							if (!flag3)
							{
								this.m_ShouldShowEnemyIndex.Add(i);
							}
						}
					}
				}
			}
			bool flag4 = this.m_ShouldShowEnemyIndex.Count > this.MaxDisplayNum;
			if (flag4)
			{
				for (int j = 0; j < this.m_ShouldShowEnemyIndex.Count; j++)
				{
					BattleIndicator battleIndicator;
					bool flag5 = this.m_EntityIndicates.TryGetValue(opponent[this.m_ShouldShowEnemyIndex[j]].ID, out battleIndicator);
					if (flag5)
					{
						this.m_TeamIndicatePool.ReturnInstance(battleIndicator.sp.gameObject, false);
						this.m_EntityIndicates.Remove(opponent[this.m_ShouldShowEnemyIndex[j]].ID);
					}
				}
			}
			else
			{
				for (int k = 0; k < this.m_ShouldShowEnemyIndex.Count; k++)
				{
					int index = this.m_ShouldShowEnemyIndex[k];
					bool flag6 = XEntity.ValideEntity(opponent[index]);
					bool flag7 = !flag6;
					BattleIndicator battleIndicator;
					bool flag8 = !this.m_EntityIndicates.TryGetValue(opponent[index].ID, out battleIndicator);
					if (flag8)
					{
						bool flag9 = !flag7;
						if (flag9)
						{
							this.CreateEntityIndicate(out battleIndicator, opponent[index], false);
						}
						else
						{
							flag7 = false;
						}
					}
					bool flag10 = flag7;
					if (!flag10)
					{
						bool flag11 = flag6;
						if (flag11)
						{
							this.ShowIndicatePosition(battleIndicator, opponent[index], false);
							this.m_ValidSet.Add(opponent[index].ID);
						}
					}
				}
			}
		}

		protected void CreateEntityIndicate(out BattleIndicator bi, XEntity e, bool IsTeamMember)
		{
			GameObject gameObject = this.m_TeamIndicatePool.FetchGameObject(false);
			IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
			bi = default(BattleIndicator);
			bi.id = e.ID;
			bi.go = gameObject;
			bi.sp = ixuisprite;
			bi.arrow = bi.go.transform.Find("arrow");
			bi.leader = (bi.go.transform.Find("leader").GetComponent("XUISprite") as IXUISprite);
			bi.xGameObject = e.EngineObject;
			this.m_EntityIndicates.Add(e.ID, bi);
			this.m_IndicatesList.Add(bi);
			if (IsTeamMember)
			{
				string teamIndicateAvatar = XSingleton<XProfessionSkillMgr>.singleton.GetTeamIndicateAvatar(e.TypeID % 10u);
				ixuisprite.SetSprite(teamIndicateAvatar);
			}
			else
			{
				ixuisprite.SetSprite("monster_00");
			}
			bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_PVP;
			if (flag)
			{
				XBattleCaptainPVPDocument specificDocument = XDocuments.GetSpecificDocument<XBattleCaptainPVPDocument>(XBattleCaptainPVPDocument.uuID);
				bool flag2 = e.ID == specificDocument.MyPosition(false);
				bi.leader.SetAlpha((float)(flag2 ? 1 : 0));
			}
			else
			{
				bi.leader.SetAlpha(0f);
			}
		}

		protected void ShowIndicatePosition(BattleIndicator bi, XEntity e, bool IsTeamMember)
		{
			bool flag = bi.xGameObject == null || XSingleton<XCutScene>.singleton.IsPlaying;
			if (flag)
			{
				bi.sp.gameObject.transform.localPosition = Vector3.one * (float)XGameUI._far_far_away;
			}
			else
			{
				Vector3 position = e.EngineObject.Position;
				Camera unityCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
				Vector3 vector = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position - position;
				bool isVisible = bi.xGameObject.IsVisible;
				if (isVisible)
				{
					if (IsTeamMember)
					{
						float num = float.Parse(XSingleton<XGlobalConfig>.singleton.GetValue("TeamIndicateDistance"));
						bool flag2 = vector.sqrMagnitude < num * num;
						if (flag2)
						{
							bi.sp.gameObject.transform.localPosition = Vector3.one * (float)XGameUI._far_far_away;
						}
						else
						{
							float num2 = e.Height + 0.6f;
							Vector3 vector2;
							vector2 = new Vector3(position.x, position.y + num2, position.z);
							Vector3 vector3 = unityCamera.WorldToViewportPoint(vector2);
							bi.sp.SetAlpha(1f);
							bi.sp.gameObject.transform.position = XSingleton<XGameUI>.singleton.UICamera.ViewportToWorldPoint(vector3);
							vector3 = bi.sp.gameObject.transform.localPosition;
							vector3.x = (float)Mathf.FloorToInt(vector3.x);
							vector3.y = (float)Mathf.FloorToInt(vector3.y);
							vector3.z = 0f;
							bi.sp.gameObject.transform.localPosition = vector3;
						}
					}
					else
					{
						bi.sp.SetAlpha(0f);
					}
				}
				else
				{
					int num3 = XSingleton<XGameUI>.singleton.Base_UI_Width / 2;
					int num4 = XSingleton<XGameUI>.singleton.Base_UI_Height / 2;
					Vector3 normalized = unityCamera.transform.forward.normalized;
					Vector3 normalized2 = unityCamera.transform.right.normalized;
					Vector3 vector4 = position - unityCamera.transform.position;
					Vector3 vector5 = position - normalized2 * Vector3.Dot(normalized2, vector4);
					Vector3 vector6 = vector5 - unityCamera.transform.position;
					Vector3 vector7 = normalized * Vector3.Dot(normalized, vector6);
					Vector3 vector8 = vector6 - vector7;
					float num5 = vector8.sqrMagnitude / vector7.sqrMagnitude;
					bool flag3 = Vector3.Dot(vector8, unityCamera.transform.up) > 0f || num5 < this._sqr_tan_half_V_fov;
					if (flag3)
					{
						vector.Set(vector.x, 0f, vector.z);
						Vector3 vector9;
						vector9 = new Vector3(unityCamera.transform.forward.x, 0f, unityCamera.transform.forward.z);
						float num6 = 0.0174532924f * Vector3.Angle(vector, vector9);
						bool flag4 = !XSingleton<XCommon>.singleton.Clockwise(vector, vector9);
						if (flag4)
						{
							num6 = -num6;
						}
						float num7 = (float)Math.Tan((double)num6) / this._tan_half_H_fov * (float)XSingleton<XGameUI>.singleton.Base_UI_Width * 0.5f;
						bool flag5 = num6 >= this._Half_H_Fov;
						if (flag5)
						{
							float num8 = num7 - (float)num3;
							float num9 = num8 * (float)num4 / num7;
							num9 = Mathf.Clamp(num9, 0f, (float)XSingleton<XGameUI>.singleton.Base_UI_Height);
							bi.go.transform.localPosition = new Vector3((float)(num3 - this.m_TeamIndicatePool.TplWidth / 2), (float)(-(float)num4) + num9, 0f);
							bi.arrow.transform.localRotation = Quaternion.identity;
							bi.arrow.transform.Rotate(0f, 0f, 90f);
							bool flag6 = num9 < 260f;
							if (flag6)
							{
								bi.sp.SetAlpha(0.5f);
							}
							else
							{
								bi.sp.SetAlpha(1f);
							}
						}
						else
						{
							float num10 = -num7 - (float)num3;
							float num11 = num10 * (float)num4 / -num7;
							num11 = Mathf.Clamp(num11, (float)(this.m_TeamIndicatePool.TplHeight / 2), (float)(XSingleton<XGameUI>.singleton.Base_UI_Height - this.m_TeamIndicatePool.TplHeight / 2));
							bi.go.transform.localPosition = new Vector3((float)(-(float)num3 + this.m_TeamIndicatePool.TplWidth / 2), (float)(-(float)num4) + num11, 0f);
							bi.arrow.transform.localRotation = Quaternion.identity;
							bi.arrow.transform.Rotate(0f, 0f, -90f);
							bi.sp.SetAlpha(1f);
						}
					}
					else
					{
						vector.Set(vector.x, 0f, vector.z);
						Vector3 vector10;
						vector10 = new Vector3(unityCamera.transform.forward.x, 0f, unityCamera.transform.forward.z);
						float num12 = 0.0174532924f * Vector3.Angle(vector, vector10);
						bool flag7 = !XSingleton<XCommon>.singleton.Clockwise(vector, vector10);
						if (flag7)
						{
							num12 = -num12;
						}
						float num13 = (float)Math.Tan((double)num12) / this._tan_half_H_fov * (float)XSingleton<XGameUI>.singleton.Base_UI_Width * 0.5f;
						bool flag8 = num12 <= this._Half_H_Fov && num12 >= -this._Half_H_Fov;
						if (flag8)
						{
							num13 = Mathf.Clamp(num13, (float)(-(float)num3 + this.m_TeamIndicatePool.TplWidth / 2), (float)(num3 - this.m_TeamIndicatePool.TplWidth / 2));
							bi.go.transform.localPosition = new Vector3(num13, (float)(-(float)num4 + this.m_TeamIndicatePool.TplHeight / 2), 0f);
							bi.arrow.transform.localRotation = Quaternion.identity;
							bool flag9 = num13 > 165f;
							if (flag9)
							{
								bi.sp.SetAlpha(0.5f);
							}
							else
							{
								bi.sp.SetAlpha(1f);
							}
						}
						else
						{
							bool flag10 = num12 > this._Half_H_Fov;
							if (flag10)
							{
								float num14 = num13 - (float)num3;
								float num15 = num14 * (float)num4 / num13;
								num15 = Mathf.Clamp(num15, 0f, (float)XSingleton<XGameUI>.singleton.Base_UI_Height);
								bi.go.transform.localPosition = new Vector3((float)(num3 - this.m_TeamIndicatePool.TplWidth / 2), (float)(-(float)num4) + num15, 0f);
								bi.arrow.transform.localRotation = Quaternion.identity;
								bi.arrow.transform.Rotate(0f, 0f, 90f);
								bool flag11 = num15 < 260f;
								if (flag11)
								{
									bi.sp.SetAlpha(0.5f);
								}
								else
								{
									bi.sp.SetAlpha(1f);
								}
							}
							else
							{
								bool flag12 = num12 < this._Half_H_Fov;
								if (flag12)
								{
									float num16 = -num13 - (float)num3;
									float num17 = num16 * (float)num4 / -num13;
									num17 = Mathf.Clamp(num17, (float)(this.m_TeamIndicatePool.TplHeight / 2), (float)(XSingleton<XGameUI>.singleton.Base_UI_Height - this.m_TeamIndicatePool.TplHeight / 2));
									bi.go.transform.localPosition = new Vector3((float)(-(float)num3 + this.m_TeamIndicatePool.TplWidth / 2), (float)(-(float)num4) + num17, 0f);
									bi.arrow.transform.localRotation = Quaternion.identity;
									bi.arrow.transform.Rotate(0f, 0f, -90f);
									bi.sp.SetAlpha(1f);
								}
							}
						}
					}
				}
			}
		}

		private bool DealWithSpectatorWatchToNull(XEntity e)
		{
			bool flag = !XSingleton<XScene>.singleton.bSpectator;
			bool result;
			if (flag)
			{
				result = false;
			}
			else
			{
				bool flag2 = XSingleton<XEntityMgr>.singleton.Player.WatchTo == null;
				if (flag2)
				{
					this._unInitEntityList.Add(e.ID);
					result = true;
				}
				else
				{
					bool flag3 = e.ID == XSingleton<XEntityMgr>.singleton.Player.WatchTo.ID && this._unInitEntityList.Count != 0;
					if (flag3)
					{
						this._campEntity = XSingleton<XEntityMgr>.singleton.Player.WatchTo;
						for (int i = 0; i < this._unInitEntityList.Count; i++)
						{
							bool flag4 = this._unInitEntityList[i] == XSingleton<XEntityMgr>.singleton.Player.WatchTo.ID;
							if (!flag4)
							{
								XEntity entityConsiderDeath = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(this._unInitEntityList[i]);
								bool flag5 = entityConsiderDeath != null;
								if (flag5)
								{
									this.MiniMapAdd(entityConsiderDeath);
								}
							}
						}
						this._unInitEntityList.Clear();
					}
					result = false;
				}
			}
			return result;
		}

		public void MiniMapAdd(XEntity e)
		{
			bool flag = e == null || e.Attributes == null;
			if (!flag)
			{
				XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(e.Attributes.TypeID);
				bool flag2 = byID != null && byID.HideInMiniMap;
				if (!flag2)
				{
					bool flag3 = this.DealWithSpectatorWatchToNull(e);
					if (!flag3)
					{
						bool flag4 = XSingleton<XEntityMgr>.singleton.IsNeutral(e) || e.IsPuppet || e.IsSubstance;
						if (!flag4)
						{
							bool flag5 = !this.m_MiniMapElements.ContainsKey(e.ID);
							if (flag5)
							{
								GameObject gameObject = this.m_MiniMapElementPool.FetchGameObject(false);
								GameObject gameObject2 = gameObject.transform.Find("Circle").gameObject;
								bool flag6 = gameObject2 != null;
								if (flag6)
								{
									gameObject2.SetActive(false);
								}
								IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
								MiniMapElement miniMapElement = new MiniMapElement();
								miniMapElement.notice = null;
								miniMapElement.sp = ixuisprite;
								ixuisprite.SetAlpha(1f);
								bool isPlayer = e.IsPlayer;
								if (isPlayer)
								{
									miniMapElement.sp.SetSprite("smap_1");
									miniMapElement.sp.MakePixelPerfect();
									miniMapElement.sp.spriteDepth = 35;
									gameObject.name = "Player";
								}
								else
								{
									bool flag7 = this.SpecialIsOpponent(this._campEntity, e);
									if (flag7)
									{
										bool isBoss = e.IsBoss;
										if (isBoss)
										{
											miniMapElement.sp.SetSprite("smap_2");
											miniMapElement.sp.MakePixelPerfect();
											miniMapElement.sp.spriteDepth = 32;
											gameObject.name = "Boss";
										}
										else
										{
											bool isElite = e.IsElite;
											if (isElite)
											{
												miniMapElement.sp.SetSprite("smap_3");
												miniMapElement.sp.MakePixelPerfect();
												miniMapElement.sp.spriteDepth = 31;
												gameObject.name = "Elite";
											}
											else
											{
												miniMapElement.sp.SetSprite("smap_6");
												miniMapElement.sp.MakePixelPerfect();
												miniMapElement.sp.spriteDepth = 30;
												gameObject.name = "Enemy";
											}
										}
									}
									else
									{
										bool flag8 = this.SpecialIsAlly(this._campEntity, e);
										if (flag8)
										{
											bool isNpc = e.IsNpc;
											if (isNpc)
											{
												miniMapElement.sp.SetSprite("smap_5");
												miniMapElement.sp.MakePixelPerfect();
												miniMapElement.sp.spriteDepth = 33;
												gameObject.name = "Npc";
											}
											else
											{
												miniMapElement.sp.SetSprite("smap_4");
												miniMapElement.sp.MakePixelPerfect();
												miniMapElement.sp.spriteDepth = 34;
												gameObject.name = "Ally";
											}
										}
										else
										{
											miniMapElement.sp.SetSprite("none");
											miniMapElement.sp.SetAlpha(0f);
										}
									}
								}
								miniMapElement.transform = gameObject.transform;
								this.m_MiniMapElements.Add(e.ID, miniMapElement);
								this.SetupMiniMapElement(e, miniMapElement, false);
							}
							this.RefreshOnMoba(e);
							this.RefreshOnHero(e);
						}
					}
				}
			}
		}

		public bool SetMiniMapElement(ulong id, string spriteName, int width = -1, int height = -1)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapElements.TryGetValue(id, out miniMapElement);
			bool result;
			if (flag)
			{
				miniMapElement.sp.SetSprite(spriteName);
				bool flag2 = width == -1 && height == -1;
				if (flag2)
				{
					miniMapElement.sp.MakePixelPerfect();
				}
				else
				{
					miniMapElement.sp.spriteWidth = width;
					miniMapElement.sp.spriteHeight = height;
				}
				result = true;
			}
			else
			{
				result = false;
			}
			return result;
		}

		public void RefreshOnMoba(XEntity e)
		{
			bool flag = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_MOBA || e.Attributes == null || XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
			if (!flag)
			{
				bool isRole = e.IsRole;
				if (isRole)
				{
					XMobaBattleDocument specificDocument = XDocuments.GetSpecificDocument<XMobaBattleDocument>(XMobaBattleDocument.uuID);
					MobaMemberData mobaMemberData = null;
					bool flag2 = specificDocument.MyData == null || !specificDocument.MobaData.TryGetValue(e.ID, out mobaMemberData);
					if (!flag2)
					{
						bool flag3 = mobaMemberData.heroID == 0u;
						if (!flag3)
						{
							this.SetHeroMiniMapElement(e.ID, mobaMemberData.heroID, specificDocument.MyData.teamID == mobaMemberData.teamID, true);
						}
					}
				}
			}
		}

		public void RefreshOnHero(XEntity e)
		{
			bool flag = XSingleton<XScene>.singleton.SceneType != SceneType.SCENE_HEROBATTLE || e.Attributes == null || XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
			if (!flag)
			{
				bool isRole = e.IsRole;
				if (isRole)
				{
					XHeroBattleDocument specificDocument = XDocuments.GetSpecificDocument<XHeroBattleDocument>(XHeroBattleDocument.uuID);
					uint num = 0u;
					bool flag2 = !specificDocument.heroIDIndex.TryGetValue(e.ID, out num);
					if (!flag2)
					{
						bool flag3 = num == 0u;
						if (!flag3)
						{
							this.SetHeroMiniMapElement(e.ID, num, XSingleton<XEntityMgr>.singleton.IsAlly(e), true);
						}
					}
				}
			}
		}

		public void SetHeroMiniMapElement(ulong id, uint heroID, bool isMyTeam, bool force = false)
		{
			bool flag = heroID == 0u;
			if (!flag)
			{
				MiniMapElement miniMapElement;
				bool flag2 = this.m_MiniMapElements.TryGetValue(id, out miniMapElement);
				if (flag2)
				{
					bool flag3 = !force && miniMapElement.heroID == heroID;
					if (!flag3)
					{
						XSingleton<XDebug>.singleton.AddGreenLog("SetMiniMap hero ele, uid = ", id.ToString(), ", heroID = ", heroID.ToString(), null, null);
						miniMapElement.heroID = heroID;
						XHeroBattleDocument specificDocument = XDocuments.GetSpecificDocument<XHeroBattleDocument>(XHeroBattleDocument.uuID);
						OverWatchTable.RowData byHeroID = specificDocument.OverWatchReader.GetByHeroID(heroID);
						miniMapElement.sp.SetSprite(byHeroID.MiniMapIcon, "Battle/battledlg2", false);
						miniMapElement.sp.MakePixelPerfect();
						if (isMyTeam)
						{
							IXUISprite sp = miniMapElement.sp;
							int num = this._heroBattleDepth_A;
							this._heroBattleDepth_A = num + 1;
							sp.spriteDepth = num;
						}
						else
						{
							IXUISprite sp2 = miniMapElement.sp;
							int num = this._heroBattleDepth_O;
							this._heroBattleDepth_O = num + 1;
							sp2.spriteDepth = num;
						}
						bool flag4 = id == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
						if (flag4)
						{
							miniMapElement.sp.spriteDepth = 300;
						}
						Transform transform = miniMapElement.sp.gameObject.transform.Find("Circle");
						bool flag5 = transform != null;
						if (flag5)
						{
							IXUISprite ixuisprite = transform.GetComponent("XUISprite") as IXUISprite;
							bool flag6 = ixuisprite != null;
							if (flag6)
							{
								ixuisprite.SetVisible(true);
								ixuisprite.SetSprite(isMyTeam ? "smhead_o" : "smhead_e");
								if (isMyTeam)
								{
									IXUISprite ixuisprite2 = ixuisprite;
									int num = this._heroBattleDepth_A;
									this._heroBattleDepth_A = num + 1;
									ixuisprite2.spriteDepth = num;
								}
								else
								{
									IXUISprite ixuisprite3 = ixuisprite;
									int num = this._heroBattleDepth_O;
									this._heroBattleDepth_O = num + 1;
									ixuisprite3.spriteDepth = num;
								}
								bool flag7 = id == XSingleton<XAttributeMgr>.singleton.XPlayerData.RoleID;
								if (flag7)
								{
									ixuisprite.spriteDepth = 301;
								}
							}
						}
					}
				}
			}
		}

		public void ResetMiniMapAllElement()
		{
			List<XEntity> all = XSingleton<XEntityMgr>.singleton.GetAll();
			for (int i = 0; i < all.Count; i++)
			{
				this.ResetMiniMapElement(all[i].ID);
			}
		}

		public bool ResetMiniMapElement(ulong id)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapElements.TryGetValue(id, out miniMapElement);
			bool result;
			if (flag)
			{
				XEntity entityConsiderDeath = XSingleton<XEntityMgr>.singleton.GetEntityConsiderDeath(id);
				bool flag2 = entityConsiderDeath == null;
				if (flag2)
				{
					result = false;
				}
				else
				{
					miniMapElement.sp.SetAlpha(1f);
					bool isPlayer = entityConsiderDeath.IsPlayer;
					if (isPlayer)
					{
						miniMapElement.sp.SetSprite("smap_1");
						miniMapElement.sp.MakePixelPerfect();
						miniMapElement.sp.spriteDepth = 35;
					}
					else
					{
						bool flag3 = this.SpecialIsOpponent(this._campEntity, entityConsiderDeath);
						if (flag3)
						{
							bool isBoss = entityConsiderDeath.IsBoss;
							if (isBoss)
							{
								miniMapElement.sp.SetSprite("smap_2");
								miniMapElement.sp.MakePixelPerfect();
								miniMapElement.sp.spriteDepth = 32;
							}
							else
							{
								bool isElite = entityConsiderDeath.IsElite;
								if (isElite)
								{
									miniMapElement.sp.SetSprite("smap_3");
									miniMapElement.sp.MakePixelPerfect();
									miniMapElement.sp.spriteDepth = 31;
								}
								else
								{
									miniMapElement.sp.SetSprite("smap_6");
									miniMapElement.sp.MakePixelPerfect();
									miniMapElement.sp.spriteDepth = 30;
								}
							}
						}
						else
						{
							bool flag4 = this.SpecialIsAlly(this._campEntity, entityConsiderDeath);
							if (flag4)
							{
								bool isNpc = entityConsiderDeath.IsNpc;
								if (isNpc)
								{
									miniMapElement.sp.SetSprite("smap_5");
									miniMapElement.sp.MakePixelPerfect();
									miniMapElement.sp.spriteDepth = 33;
								}
								else
								{
									miniMapElement.sp.SetSprite("smap_4");
									miniMapElement.sp.MakePixelPerfect();
									miniMapElement.sp.spriteDepth = 34;
								}
							}
							else
							{
								XSingleton<XDebug>.singleton.AddGreenLog("null", null, null, null, null, null);
								miniMapElement.sp.SetAlpha(0f);
							}
						}
					}
					this.RefreshOnMoba(entityConsiderDeath);
					this.RefreshOnHero(entityConsiderDeath);
					result = true;
				}
			}
			else
			{
				result = false;
			}
			return result;
		}

		private bool SpecialIsOpponent(XEntity e1, XEntity e2)
		{
			bool flag = XSingleton<XScene>.singleton.bSpectator && XSingleton<XSceneMgr>.singleton.IsPVPScene() && e2.IsRole;
			bool result;
			if (flag)
			{
				XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument<XSpectateSceneDocument>(XSpectateSceneDocument.uuID);
				bool flag3;
				bool flag2 = !specificDocument.TryGetEntityIsBlueTeam(e2, out flag3);
				result = (!flag2 && !flag3);
			}
			else
			{
				result = XSingleton<XEntityMgr>.singleton.IsOpponent(e1, e2);
			}
			return result;
		}

		private bool SpecialIsAlly(XEntity e1, XEntity e2)
		{
			bool flag = XSingleton<XScene>.singleton.bSpectator && XSingleton<XSceneMgr>.singleton.IsPVPScene() && e2.IsRole;
			bool result;
			if (flag)
			{
				XSpectateSceneDocument specificDocument = XDocuments.GetSpecificDocument<XSpectateSceneDocument>(XSpectateSceneDocument.uuID);
				bool flag3;
				bool flag2 = !specificDocument.TryGetEntityIsBlueTeam(e2, out flag3);
				result = (!flag2 && flag3);
			}
			else
			{
				result = XSingleton<XEntityMgr>.singleton.IsAlly(e1, e2);
			}
			return result;
		}

		public static void SetMiniMapOpponentStatus(bool hide)
		{
			BattleIndicateHandler._hide_minimap_opponent = hide;
		}

		public void MiniMapAddDoor(Transform go)
		{
			Transform transform = go.Find("Target");
			bool flag = transform != null;
			if (flag)
			{
				GameObject gameObject = this.m_MiniMapElementPool.FetchGameObject(false);
				GameObject gameObject2 = gameObject.transform.Find("Circle").gameObject;
				bool flag2 = gameObject2 != null;
				if (flag2)
				{
					gameObject2.SetActive(false);
				}
				IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
				ixuisprite.SetAlpha(1f);
				MiniMapElement miniMapElement = new MiniMapElement();
				miniMapElement.notice = null;
				miniMapElement.sp = ixuisprite;
				miniMapElement.sp.SetSprite("smap_7");
				miniMapElement.sp.MakePixelPerfect();
				gameObject.name = "Door";
				miniMapElement.transform = go;
				this.m_MiniMapDoor.Add(miniMapElement);
				this.SetupMiniMapStatic(miniMapElement);
			}
		}

		public void OnMonsterDie(XEntity e)
		{
		}

		public void MiniMapDel(ulong uid)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapElements.TryGetValue(uid, out miniMapElement);
			if (flag)
			{
				this.m_MiniMapElements.Remove(uid);
				this.DestroyFx(miniMapElement.notice);
				miniMapElement.notice = null;
				this.m_MiniMapElementPool.ReturnInstance(miniMapElement.sp.gameObject, false);
			}
		}

		public void MiniMapDel(XEntity e)
		{
			bool flag = XSingleton<XEntityMgr>.singleton.IsAlly(e);
			if (!flag)
			{
				MiniMapElement miniMapElement;
				bool flag2 = this.m_MiniMapElements.TryGetValue(e.ID, out miniMapElement);
				if (flag2)
				{
					this.m_MiniMapElements.Remove(e.ID);
					this.DestroyFx(miniMapElement.notice);
					miniMapElement.notice = null;
					this.m_MiniMapElementPool.ReturnInstance(miniMapElement.sp.gameObject, false);
				}
			}
		}

		public void MiniMapNoticeAdd(XEntity e)
		{
			MiniMapElement element;
			bool flag = this.m_MiniMapElements.TryGetValue(e.ID, out element);
			if (flag)
			{
				this.CreateAndPlayFxFxFirework(element);
			}
		}

		public void MiniMapBuffAdd(XLevelDoodad doo)
		{
			BuffTable.RowData buffData = XSingleton<XBuffTemplateManager>.singleton.GetBuffData((int)doo.id, 1);
			bool flag = buffData == null;
			if (!flag)
			{
				bool flag2 = string.IsNullOrEmpty(buffData.MiniMapIcon);
				if (!flag2)
				{
					bool flag3 = !this.m_MiniMapDoodadDic.ContainsKey((ulong)doo.index);
					if (flag3)
					{
						GameObject gameObject = this.m_MiniMapElementPool.FetchGameObject(false);
						GameObject gameObject2 = gameObject.transform.Find("Circle").gameObject;
						bool flag4 = gameObject2 != null;
						if (flag4)
						{
							gameObject2.SetActive(false);
						}
						IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
						MiniMapElement miniMapElement = new MiniMapElement();
						miniMapElement.notice = null;
						miniMapElement.sp = ixuisprite;
						ixuisprite.SetAlpha(1f);
						miniMapElement.sp.SetSprite(buffData.MiniMapIcon);
						miniMapElement.sp.MakePixelPerfect();
						miniMapElement.sp.spriteDepth = 36;
						gameObject.name = "Buff";
						miniMapElement.transform = doo.doodad.transform;
						this.m_MiniMapBuff.Add(miniMapElement);
						this.m_MiniMapDoodadDic.Add((ulong)doo.index, miniMapElement);
						this.SetupMiniMapStatic(miniMapElement);
					}
				}
			}
		}

		public void MiniMapBuffDel(XLevelDoodad doo)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapDoodadDic.TryGetValue((ulong)doo.index, out miniMapElement);
			if (flag)
			{
				this.m_MiniMapBuff.Remove(miniMapElement);
				this.m_MiniMapDoodadDic.Remove((ulong)doo.index);
				this.DestroyFx(miniMapElement.notice);
				miniMapElement.notice = null;
				this.m_MiniMapElementPool.ReturnInstance(miniMapElement.sp.gameObject, false);
			}
		}

		public uint MiniMapFxAdd(Vector3 pos, string fx)
		{
			GameObject gameObject = this.m_MiniMapElementPool.FetchGameObject(false);
			GameObject gameObject2 = gameObject.transform.Find("Circle").gameObject;
			bool flag = gameObject2 != null;
			if (flag)
			{
				gameObject2.SetActive(false);
			}
			IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
			MiniMapElement miniMapElement = new MiniMapElement();
			miniMapElement.notice = XSingleton<XFxMgr>.singleton.CreateFx(fx, null, true);
			bool flag2 = miniMapElement.notice != null;
			if (flag2)
			{
				miniMapElement.notice.Play(ixuisprite.transform, Vector3.zero, Vector3.one, 1f, true, false);
				XSingleton<XGameUI>.singleton.m_uiTool.MarkParentAsChanged(ixuisprite.gameObject);
			}
			miniMapElement.sp = ixuisprite;
			ixuisprite.SetAlpha(1f);
			miniMapElement.pos = pos;
			miniMapElement.sp.SetSprite("");
			gameObject.name = "Fx";
			miniMapElement.transform = null;
			this.m_MiniMapFxToken += 1u;
			this.m_MiniMapFx.Add(miniMapElement);
			this.m_MiniMapFxDic.Add((ulong)this.m_MiniMapFxToken, miniMapElement);
			this.SetupMiniMapFxStatic(miniMapElement);
			return this.m_MiniMapFxToken;
		}

		public void MiniMapFxDel(uint token)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapFxDic.TryGetValue((ulong)token, out miniMapElement);
			if (flag)
			{
				this.m_MiniMapFx.Remove(miniMapElement);
				this.m_MiniMapFxDic.Remove((ulong)token);
				this.DestroyFx(miniMapElement.notice);
				miniMapElement.notice = null;
				this.m_MiniMapElementPool.ReturnInstance(miniMapElement.sp.gameObject, false);
			}
		}

		public uint MiniMapPicAdd(Vector3 pos, string pic)
		{
			GameObject gameObject = this.m_MiniMapElementPool.FetchGameObject(false);
			GameObject gameObject2 = gameObject.transform.Find("Circle").gameObject;
			bool flag = gameObject2 != null;
			if (flag)
			{
				gameObject2.SetActive(false);
			}
			IXUISprite ixuisprite = gameObject.GetComponent("XUISprite") as IXUISprite;
			MiniMapElement miniMapElement = new MiniMapElement();
			miniMapElement.notice = null;
			miniMapElement.sp = ixuisprite;
			ixuisprite.SetAlpha(1f);
			miniMapElement.pos = pos;
			miniMapElement.sp.SetSprite(pic);
			miniMapElement.sp.MakePixelPerfect();
			miniMapElement.sp.transform.localEulerAngles = -this.m_MiniMapRotation.transform.eulerAngles;
			miniMapElement.sp.spriteDepth = 36;
			gameObject.name = "Pic";
			miniMapElement.transform = null;
			this.m_MiniMapPicToken += 1u;
			this.m_MiniMapPic.Add(miniMapElement);
			this.m_MiniMapPicDic.Add((ulong)this.m_MiniMapPicToken, miniMapElement);
			this.SetupMiniMapPicStatic(miniMapElement);
			return this.m_MiniMapPicToken;
		}

		public void MiniMapPicDel(uint token)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapPicDic.TryGetValue((ulong)token, out miniMapElement);
			if (flag)
			{
				this.m_MiniMapPic.Remove(miniMapElement);
				this.m_MiniMapPicDic.Remove((ulong)token);
				this.m_MiniMapElementPool.ReturnInstance(miniMapElement.sp.gameObject, false);
			}
		}

		public void CreateAndPlayFxFxFirework(MiniMapElement element)
		{
			this.DestroyFx(element.notice);
			element.notice = null;
			element.notice = XSingleton<XFxMgr>.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_xdtts", null, true);
			element.notice.Play(element.sp.transform, Vector3.zero, Vector3.one, 1f, true, false);
			XSingleton<XGameUI>.singleton.m_uiTool.MarkParentAsChanged(element.sp.gameObject);
		}

		private void DestroyFx(XFx fx)
		{
			bool flag = fx == null;
			if (!flag)
			{
				XSingleton<XFxMgr>.singleton.DestroyFx(fx, true);
			}
		}

		public void MiniMapNoticeDel(XEntity e)
		{
			MiniMapElement miniMapElement;
			bool flag = this.m_MiniMapElements.TryGetValue(e.ID, out miniMapElement);
			if (flag)
			{
				this.DestroyFx(miniMapElement.notice);
				miniMapElement.notice = null;
			}
		}

		public void ShowDirection(Transform target)
		{
			this.m_CachedDirectionTarget = target;
			bool flag = !XSingleton<XScene>.singleton.bSpectator;
			if (flag)
			{
				this.m_Direction.localPosition = this.m_DirectPos;
			}
		}

		public void UpdateDirection()
		{
			bool flag = this.m_CachedDirectionTarget != null;
			if (flag)
			{
				XPlayer player = XSingleton<XEntityMgr>.singleton.Player;
				Camera unityCamera = XSingleton<XScene>.singleton.GameCamera.UnityCamera;
				Vector3 position = player.EngineObject.Position;
				Vector3 vector;
				vector = new Vector3(this.m_CachedDirectionTarget.transform.position.x, 0f, this.m_CachedDirectionTarget.transform.position.z);
				Vector3 vector2;
				vector2 = new Vector3(position.x, 0f, position.z);
				Vector3 vector3 = vector - vector2;
				Vector3 vector4;
				vector4 = new Vector3(unityCamera.transform.forward.x, 0f, unityCamera.transform.forward.z);
				float sqrMagnitude = vector3.sqrMagnitude;
				float num = Vector3.Angle(vector4, vector3);
				bool flag2 = XSingleton<XCommon>.singleton.Clockwise(vector4, vector3);
				if (flag2)
				{
					this.m_Direction.transform.localRotation = Quaternion.AngleAxis(-num, Vector3.forward);
				}
				else
				{
					this.m_Direction.transform.localRotation = Quaternion.AngleAxis(num, Vector3.forward);
				}
				bool flag3 = sqrMagnitude < 50f;
				if (flag3)
				{
					this.m_Direction.localPosition = XGameUI.Far_Far_Away;
					this.m_CachedDirectionTarget = null;
				}
			}
		}

		public void ClearTeamIndicate()
		{
			this.m_EntityIndicates.Clear();
			this.m_TeamIndicatePool.ReturnAll(false);
			this.m_IndicatesList.Clear();
		}

		public void ChangeWatchToEntity(XEntity e)
		{
			this._campEntity = e;
		}
	}
}