diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs | 1508 |
1 files changed, 1508 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs b/Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs new file mode 100644 index 00000000..f9d5f174 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/UI/BattleIndicateHandler.cs @@ -0,0 +1,1508 @@ +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;
+ }
+ }
+}
|