using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("minimap ext")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("minimap ext")]
[assembly: AssemblyTitle("minimap ext")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MinimapEntityExtension
{
	internal sealed class EntityMarkerController : IDisposable
	{
		private const float ScanIntervalSeconds = 0.5f;

		private const int HeadColorSlot = 5;

		private const int OutlineRendererCount = 8;

		private const int OutlineSortingOrder = 0;

		private const int MainMarkerSortingOrder = 1;

		private static readonly FieldInfo? enemyParentEnemyField = AccessTools.Field(typeof(EnemyParent), "Enemy");

		private static readonly FieldInfo? enemyParentSpawnedField = AccessTools.Field(typeof(EnemyParent), "Spawned");

		private readonly ManualLogSource logger;

		private readonly ConfigEntry<bool> showPlayers;

		private readonly ConfigEntry<bool> showEnemies;

		private readonly Dictionary<PlayerAvatar, MarkerEntry> playerMarkers = new Dictionary<PlayerAvatar, MarkerEntry>();

		private readonly Dictionary<EnemyParent, MarkerEntry> enemyMarkers = new Dictionary<EnemyParent, MarkerEntry>();

		private readonly FieldInfo? playerDisabledField = AccessTools.Field(typeof(PlayerAvatar), "isDisabled");

		private readonly FieldInfo? playerIsLocalField = AccessTools.Field(typeof(PlayerAvatar), "isLocal");

		private readonly FieldInfo? playerAvatarInstanceField = AccessTools.Field(typeof(PlayerAvatar), "instance");

		private readonly FieldInfo? playerControllerInstanceField = AccessTools.Field(typeof(PlayerController), "instance");

		private readonly FieldInfo? playerControllerAvatarField = AccessTools.Field(typeof(PlayerController), "playerAvatarScript");

		private readonly FieldInfo? playerColorsEquippedField = AccessTools.Field(typeof(PlayerCosmetics), "colorsEquipped");

		private Map? currentMap;

		private Transform? currentOverlayParent;

		private Sprite? fallbackSprite;

		private float scanTimer;

		private float nextCreateAttemptTime;

		private float nextCreateFailureLogTime;

		public EntityMarkerController(ManualLogSource logger, ConfigEntry<bool> showPlayers, ConfigEntry<bool> showEnemies)
		{
			this.logger = logger;
			this.showPlayers = showPlayers;
			this.showEnemies = showEnemies;
			if (playerDisabledField == null)
			{
				logger.LogWarning((object)"PlayerAvatar.isDisabled field was not found; disabled players will be treated as alive on the minimap.");
			}
			if (playerIsLocalField == null)
			{
				logger.LogWarning((object)"PlayerAvatar.isLocal field was not found; local player filtering will use instance fallbacks.");
			}
			if (playerColorsEquippedField == null)
			{
				logger.LogWarning((object)"PlayerCosmetics.colorsEquipped field was not found; player minimap markers will use the fallback color.");
			}
		}

		public void Update(float deltaTime)
		{
			Map instance = Map.Instance;
			if (!IsMapReady(instance))
			{
				ClearAllMarkers();
				currentMap = null;
				currentOverlayParent = null;
				scanTimer = 0f;
				return;
			}
			if ((Object)(object)currentMap != (Object)(object)instance || (Object)(object)currentOverlayParent != (Object)(object)instance.OverLayerParent)
			{
				ClearAllMarkers();
				currentMap = instance;
				currentOverlayParent = instance.OverLayerParent;
				scanTimer = 0f;
			}
			bool value = showPlayers.Value;
			bool value2 = showEnemies.Value;
			if (!value)
			{
				ClearPlayerMarkers();
			}
			if (!value2)
			{
				ClearEnemyMarkers();
			}
			scanTimer -= deltaTime;
			if (scanTimer <= 0f)
			{
				scanTimer = 0.5f;
				if (value)
				{
					ScanPlayers(instance);
				}
				if (value2)
				{
					ScanEnemies(instance);
				}
			}
			if (value)
			{
				UpdatePlayerMarkers(instance);
			}
			if (value2)
			{
				UpdateEnemyMarkers(instance);
			}
		}

		public void Dispose()
		{
			ClearAllMarkers();
			DestroySprite(ref fallbackSprite);
		}

		private static bool IsMapReady(Map? map)
		{
			return (Object)(object)map != (Object)null && (Object)(object)map.CustomObject != (Object)null && (Object)(object)map.OverLayerParent != (Object)null;
		}

		private void ScanPlayers(Map map)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerAvatar> list = GameDirector.instance?.PlayerList;
			if (list == null)
			{
				RemoveMissing(playerMarkers, (PlayerAvatar _) => false);
				return;
			}
			HashSet<PlayerAvatar> seen = new HashSet<PlayerAvatar>();
			foreach (PlayerAvatar item in list)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)((Component)item).transform == (Object)null || IsLocalPlayer(item))
				{
					continue;
				}
				seen.Add(item);
				if (playerMarkers.TryGetValue(item, out MarkerEntry value))
				{
					if (IsMarkerEntryValid(value, map, ((Component)item).transform))
					{
						continue;
					}
					value.Destroy();
					playerMarkers.Remove(item);
				}
				bool showOutline = !IsPlayerDisabled(item);
				MarkerEntry markerEntry = TryCreateMarker(map, ((Component)item).transform, "Player", ResolvePlayerMarkerColor(item), showOutline, Color.green);
				if (markerEntry != null)
				{
					playerMarkers[item] = markerEntry;
				}
			}
			RemoveMissing(playerMarkers, (PlayerAvatar player) => (Object)(object)player != (Object)null && seen.Contains(player));
		}

		private void ScanEnemies(Map map)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			List<EnemyParent> list = EnemyDirector.instance?.enemiesSpawned;
			if (list == null)
			{
				RemoveMissing(enemyMarkers, (EnemyParent _) => false);
				return;
			}
			HashSet<EnemyParent> seen = new HashSet<EnemyParent>();
			foreach (EnemyParent item in list)
			{
				Transform val = ResolveEnemyMarkerTarget(item);
				if ((Object)(object)item == (Object)null || (Object)(object)val == (Object)null)
				{
					continue;
				}
				seen.Add(item);
				if (enemyMarkers.TryGetValue(item, out MarkerEntry value))
				{
					if (IsMarkerEntryValid(value, map, val))
					{
						continue;
					}
					value.Destroy();
					enemyMarkers.Remove(item);
				}
				MarkerEntry markerEntry = TryCreateMarker(map, val, "Enemy", Color.black, showOutline: true, Color.red);
				if (markerEntry != null)
				{
					enemyMarkers[item] = markerEntry;
				}
			}
			RemoveMissing(enemyMarkers, (EnemyParent enemy) => (Object)(object)enemy != (Object)null && seen.Contains(enemy));
		}

		private void UpdatePlayerMarkers(Map map)
		{
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<PlayerAvatar, MarkerEntry> playerMarker in playerMarkers)
			{
				PlayerAvatar key = playerMarker.Key;
				MarkerEntry value = playerMarker.Value;
				bool visible = (Object)(object)key != (Object)null && !IsLocalPlayer(key) && (IsPlayerDisabled(key) || ((Component)key).gameObject.activeInHierarchy);
				bool showOutline = (Object)(object)key != (Object)null && !IsPlayerDisabled(key);
				UpdateMarker(map, value, ((Object)(object)key != (Object)null) ? ((Component)key).transform : null, visible, ResolvePlayerMarkerColor(key), showOutline, Color.green);
			}
		}

		private void UpdateEnemyMarkers(Map map)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<EnemyParent, MarkerEntry> enemyMarker in enemyMarkers)
			{
				EnemyParent key = enemyMarker.Key;
				MarkerEntry value = enemyMarker.Value;
				Transform target = ResolveEnemyMarkerTarget(key);
				bool visible = IsEnemyVisible(key);
				UpdateMarker(map, value, target, visible, Color.black, showOutline: true, Color.red);
			}
		}

		private static Transform? ResolveEnemyMarkerTarget(EnemyParent? enemyParent)
		{
			if ((Object)(object)enemyParent == (Object)null)
			{
				return null;
			}
			object obj = enemyParentEnemyField?.GetValue(enemyParent);
			Enemy val = (Enemy)((obj is Enemy) ? obj : null);
			if (val != null)
			{
				Transform centerTransform = val.CenterTransform;
				if ((Object)(object)centerTransform != (Object)null)
				{
					return centerTransform;
				}
				if ((Object)(object)((Component)val).transform != (Object)null)
				{
					return ((Component)val).transform;
				}
			}
			return ((Component)enemyParent).transform;
		}

		private static bool IsEnemyVisible(EnemyParent? enemy)
		{
			if ((Object)(object)enemy == (Object)null || (Object)(object)enemy.EnableObject == (Object)null || !enemy.EnableObject.activeInHierarchy)
			{
				return false;
			}
			object obj = enemyParentSpawnedField?.GetValue(enemy);
			bool flag = default(bool);
			int num;
			if (obj is bool)
			{
				flag = (bool)obj;
				num = ((1 == 0) ? 1 : 0);
			}
			else
			{
				num = 1;
			}
			return (byte)((uint)num | (flag ? 1u : 0u)) != 0;
		}

		private static void UpdateMarker(Map map, MarkerEntry marker, Transform? target, bool visible, Color color, bool showOutline, Color outlineColor)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)marker.GameObject == (Object)null || (Object)(object)marker.Renderer == (Object)null)
			{
				return;
			}
			marker.GameObject.SetActive(visible && map.Active);
			marker.Renderer.color = color;
			UpdateOutlineRenderers(marker.Renderer, marker.OutlineRenderers, showOutline, outlineColor);
			if (visible && (Object)(object)target != (Object)null)
			{
				if ((Object)(object)marker.MapEntity != (Object)null)
				{
					marker.MapEntity.Parent = target;
				}
				map.CustomPositionSet(marker.GameObject.transform, target);
			}
		}

		private static SpriteRenderer[] CreateOutlineRenderers(SpriteRenderer renderer, bool showOutline, Color outlineColor)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			SpriteRenderer[] array = (SpriteRenderer[])(object)new SpriteRenderer[8];
			for (int i = 0; i < array.Length; i++)
			{
				GameObject val = new GameObject($"MinimapEntityExtension Outline {i + 1}");
				val.layer = ((Component)renderer).gameObject.layer;
				Transform transform = val.transform;
				transform.SetParent(((Component)renderer).transform, false);
				transform.localPosition = Vector3.zero;
				transform.localRotation = Quaternion.identity;
				transform.localScale = Vector3.one;
				array[i] = val.AddComponent<SpriteRenderer>();
			}
			UpdateOutlineRenderers(renderer, array, showOutline, outlineColor);
			return array;
		}

		private static void UpdateOutlineRenderers(SpriteRenderer renderer, IReadOnlyList<SpriteRenderer>? outlineRenderers, bool showOutline, Color outlineColor)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			if (outlineRenderers == null)
			{
				return;
			}
			Sprite sprite = renderer.sprite;
			if (!showOutline || !((Renderer)renderer).enabled || (Object)(object)sprite == (Object)null)
			{
				for (int i = 0; i < outlineRenderers.Count; i++)
				{
					SpriteRenderer val = outlineRenderers[i];
					if ((Object)(object)val != (Object)null)
					{
						((Renderer)val).enabled = false;
					}
				}
				return;
			}
			float pixelsPerUnit = sprite.pixelsPerUnit;
			float pixel = ((pixelsPerUnit > 0f) ? (1f / pixelsPerUnit) : 0f);
			for (int j = 0; j < outlineRenderers.Count; j++)
			{
				SpriteRenderer val2 = outlineRenderers[j];
				if (!((Object)(object)val2 == (Object)null))
				{
					((Renderer)val2).enabled = true;
					val2.sprite = sprite;
					((Renderer)val2).sharedMaterial = ((Renderer)renderer).sharedMaterial;
					val2.color = outlineColor;
					val2.flipX = renderer.flipX;
					val2.flipY = renderer.flipY;
					val2.drawMode = renderer.drawMode;
					val2.maskInteraction = renderer.maskInteraction;
					((Component)val2).gameObject.layer = ((Component)renderer).gameObject.layer;
					((Renderer)val2).sortingLayerID = ((Renderer)renderer).sortingLayerID;
					((Renderer)val2).sortingOrder = 0;
					((Component)val2).transform.localPosition = GetOutlineOffset(j, pixel);
					((Component)val2).transform.localRotation = Quaternion.identity;
					((Component)val2).transform.localScale = Vector3.one;
				}
			}
		}

		private static Vector3 GetOutlineOffset(int index, float pixel)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			Vector3 result = (Vector3)(index switch
			{
				0 => new Vector3(pixel, 0f, 0f), 
				1 => new Vector3(0f - pixel, 0f, 0f), 
				2 => new Vector3(0f, pixel, 0f), 
				3 => new Vector3(0f, 0f - pixel, 0f), 
				4 => new Vector3(pixel, pixel, 0f), 
				5 => new Vector3(pixel, 0f - pixel, 0f), 
				6 => new Vector3(0f - pixel, pixel, 0f), 
				7 => new Vector3(0f - pixel, 0f - pixel, 0f), 
				_ => Vector3.zero, 
			});
			if (1 == 0)
			{
			}
			return result;
		}

		private MarkerEntry CreateMarker(Map map, Transform target, string kind, Color color, bool showOutline, Color outlineColor)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			try
			{
				val = Object.Instantiate<GameObject>(map.CustomObject, map.OverLayerParent);
				((Object)val).name = "MinimapEntityExtension " + kind + " Marker";
				MapCustomEntity component = val.GetComponent<MapCustomEntity>();
				SpriteRenderer val2 = (((Object)(object)component != (Object)null) ? component.spriteRenderer : val.GetComponentInChildren<SpriteRenderer>());
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = val.AddComponent<SpriteRenderer>();
					logger.LogWarning((object)("Created fallback SpriteRenderer for " + kind + " marker because CustomObject had none."));
				}
				int sortingLayerID = ((Renderer)val2).sortingLayerID;
				int sortingOrder = ((Renderer)val2).sortingOrder;
				SortingGroup val3 = val.GetComponent<SortingGroup>() ?? val.AddComponent<SortingGroup>();
				val3.sortingLayerID = sortingLayerID;
				val3.sortingOrder = sortingOrder;
				if ((Object)(object)component != (Object)null)
				{
					component.Parent = target;
					component.spriteRenderer = val2;
				}
				if ((Object)(object)val2.sprite == (Object)null)
				{
					val2.sprite = GetFallbackSprite();
				}
				((Renderer)val2).sortingLayerID = sortingLayerID;
				((Renderer)val2).sortingOrder = 1;
				val2.color = color;
				SpriteRenderer[] outlineRenderers = CreateOutlineRenderers(val2, showOutline, outlineColor);
				map.CustomPositionSet(val.transform, target);
				val.SetActive(map.Active);
				return new MarkerEntry(val, val2, outlineRenderers, component);
			}
			catch
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
				throw;
			}
		}

		private MarkerEntry? TryCreateMarker(Map map, Transform target, string kind, Color color, bool showOutline, Color outlineColor)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			float unscaledTime = Time.unscaledTime;
			if (unscaledTime < nextCreateAttemptTime)
			{
				return null;
			}
			try
			{
				return CreateMarker(map, target, kind, color, showOutline, outlineColor);
			}
			catch (Exception ex)
			{
				nextCreateAttemptTime = unscaledTime + 2f;
				if (unscaledTime >= nextCreateFailureLogTime)
				{
					nextCreateFailureLogTime = unscaledTime + 10f;
					logger.LogWarning((object)("Failed to create " + kind + " minimap marker; will retry later. " + ex.GetType().Name + ": " + ex.Message));
				}
				return null;
			}
		}

		private static bool IsMarkerEntryValid(MarkerEntry marker, Map map, Transform target)
		{
			if ((Object)(object)marker.GameObject == (Object)null || (Object)(object)marker.Renderer == (Object)null || (Object)(object)target == (Object)null)
			{
				return false;
			}
			Transform transform = marker.GameObject.transform;
			if ((Object)(object)transform == (Object)null || (Object)(object)transform.parent != (Object)(object)map.OverLayerParent)
			{
				return false;
			}
			MapCustomEntity mapEntity = marker.MapEntity;
			if ((Object)(object)mapEntity == (Object)null)
			{
				return !marker.HadMapEntity;
			}
			return (Object)(object)mapEntity.Parent == (Object)(object)target;
		}

		private Color ResolvePlayerMarkerColor(PlayerAvatar? player)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(object)player != (Object)null && IsPlayerDisabled(player)) ? Color.red : ResolvePlayerHeadColor(player);
		}

		private Color ResolvePlayerHeadColor(PlayerAvatar? player)
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)player == (Object)null || (Object)(object)player.playerCosmetics == (Object)null || (Object)(object)MetaManager.instance == (Object)null || MetaManager.instance.colors == null)
				{
					return Color.cyan;
				}
				if (!(playerColorsEquippedField?.GetValue(player.playerCosmetics) is int[] array) || array.Length <= 5)
				{
					return Color.cyan;
				}
				int num = array[5];
				if (num < 0 || num >= MetaManager.instance.colors.Count || (Object)(object)MetaManager.instance.colors[num] == (Object)null)
				{
					return Color.cyan;
				}
				Color color = MetaManager.instance.colors[num].color;
				color.a = 1f;
				return color;
			}
			catch (Exception ex)
			{
				logger.LogDebug((object)("Failed to resolve player head color: " + ex.Message));
				return Color.cyan;
			}
		}

		private bool IsPlayerDisabled(PlayerAvatar player)
		{
			try
			{
				object obj = playerDisabledField?.GetValue(player);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
			catch (Exception ex)
			{
				logger.LogDebug((object)("Failed to read PlayerAvatar.isDisabled: " + ex.Message));
				return false;
			}
		}

		private bool IsLocalPlayer(PlayerAvatar player)
		{
			try
			{
				object obj = playerIsLocalField?.GetValue(player);
				bool flag = default(bool);
				int num;
				if (obj is bool)
				{
					flag = (bool)obj;
					num = 1;
				}
				else
				{
					num = 0;
				}
				if (((uint)num & (flag ? 1u : 0u)) != 0)
				{
					return true;
				}
				if (player == GetPlayerAvatarInstance())
				{
					return true;
				}
				return player == GetPlayerControllerAvatar();
			}
			catch (Exception ex)
			{
				logger.LogDebug((object)("Failed to determine whether player is local: " + ex.Message));
				return false;
			}
		}

		private PlayerAvatar? GetPlayerAvatarInstance()
		{
			object? obj = playerAvatarInstanceField?.GetValue(null);
			return (PlayerAvatar?)((obj is PlayerAvatar) ? obj : null);
		}

		private PlayerAvatar? GetPlayerControllerAvatar()
		{
			object obj = playerControllerInstanceField?.GetValue(null);
			if (obj == null)
			{
				return null;
			}
			object? obj2 = playerControllerAvatarField?.GetValue(obj);
			return (PlayerAvatar?)((obj2 is PlayerAvatar) ? obj2 : null);
		}

		private Sprite GetFallbackSprite()
		{
			return fallbackSprite ?? (fallbackSprite = SpriteFactory.CreateCircleSprite("MinimapEntityExtension_FallbackDot", 32));
		}

		private static void RemoveMissing<TKey>(Dictionary<TKey, MarkerEntry> markers, Func<TKey, bool> keep) where TKey : class
		{
			List<TKey> list = null;
			foreach (TKey key in markers.Keys)
			{
				if (!keep(key))
				{
					if (list == null)
					{
						list = new List<TKey>();
					}
					list.Add(key);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (TKey item in list)
			{
				if (markers.TryGetValue(item, out MarkerEntry value))
				{
					value.Destroy();
				}
				markers.Remove(item);
			}
		}

		private void ClearAllMarkers()
		{
			ClearPlayerMarkers();
			ClearEnemyMarkers();
		}

		private void ClearPlayerMarkers()
		{
			foreach (MarkerEntry value in playerMarkers.Values)
			{
				value.Destroy();
			}
			playerMarkers.Clear();
		}

		private void ClearEnemyMarkers()
		{
			foreach (MarkerEntry value in enemyMarkers.Values)
			{
				value.Destroy();
			}
			enemyMarkers.Clear();
		}

		private static void DestroySprite(ref Sprite? sprite)
		{
			if ((Object)(object)sprite != (Object)null)
			{
				if ((Object)(object)sprite.texture != (Object)null)
				{
					Object.Destroy((Object)(object)sprite.texture);
				}
				Object.Destroy((Object)(object)sprite);
				sprite = null;
			}
		}
	}
	internal sealed class MarkerEntry
	{
		public GameObject GameObject { get; }

		public SpriteRenderer Renderer { get; }

		public SpriteRenderer[] OutlineRenderers { get; }

		public MapCustomEntity? MapEntity { get; }

		public bool HadMapEntity { get; }

		public MarkerEntry(GameObject gameObject, SpriteRenderer renderer, SpriteRenderer[] outlineRenderers, MapCustomEntity? mapEntity)
		{
			GameObject = gameObject;
			Renderer = renderer;
			OutlineRenderers = outlineRenderers;
			MapEntity = mapEntity;
			HadMapEntity = (Object)(object)mapEntity != (Object)null;
		}

		public void Destroy()
		{
			if ((Object)(object)GameObject != (Object)null)
			{
				Object.Destroy((Object)(object)GameObject);
			}
		}
	}
	[BepInPlugin("com.zhuanban.repo.minimapentityextension", "minimap ext", "0.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.zhuanban.repo.minimapentityextension";

		public const string PluginName = "minimap ext";

		public const string PluginVersion = "0.1.0";

		private EntityMarkerController? controller;

		private void Awake()
		{
			ConfigEntry<bool> showPlayers = ((BaseUnityPlugin)this).Config.Bind<bool>("Markers", "ShowPlayers", true, "Show player minimap markers for remote players.");
			ConfigEntry<bool> showEnemies = ((BaseUnityPlugin)this).Config.Bind<bool>("Markers", "ShowEnemies", true, "Show enemy minimap markers.");
			controller = new EntityMarkerController(((BaseUnityPlugin)this).Logger, showPlayers, showEnemies);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"minimap ext 0.1.0 loaded; waiting for Minimap runtime objects.");
		}

		private void Update()
		{
			controller?.Update(Time.deltaTime);
		}

		private void OnDestroy()
		{
			controller?.Dispose();
			controller = null;
		}
	}
	internal static class SpriteFactory
	{
		public static Sprite CreateCircleSprite(string name, int size)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false)
			{
				name = name,
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color32 val2 = default(Color32);
			((Color32)(ref val2))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, (byte)0);
			Color32 val3 = default(Color32);
			((Color32)(ref val3))..ctor(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
			float num = (float)(size - 2) * 0.5f;
			Vector2 val4 = default(Vector2);
			((Vector2)(ref val4))..ctor((float)(size - 1) * 0.5f, (float)(size - 1) * 0.5f);
			Color32[] array = (Color32[])(object)new Color32[size * size];
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num2 = Vector2.Distance(new Vector2((float)j, (float)i), val4);
					array[i * size + j] = ((num2 <= num) ? val3 : val2);
				}
			}
			val.SetPixels32(array);
			val.Apply(false, true);
			Sprite val5 = Sprite.Create(val, new Rect(0f, 0f, (float)size, (float)size), new Vector2(0.5f, 0.5f), (float)size);
			((Object)val5).name = name;
			return val5;
		}
	}
}