using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AIGraph;
using AK;
using Agents;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using GameData;
using Gear;
using Hikaria.Core;
using Hikaria.ItemMarker.Features;
using Hikaria.ItemMarker.Handlers;
using Hikaria.ItemMarker.Handlers.Markers;
using Hikaria.ItemMarker.Managers;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using LevelGeneration;
using Player;
using SNetwork;
using TMPro;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Patches;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.Localization;
using TheArchive.Core.Models;
using TheArchive.Core.ModulesAPI;
using TheArchive.Interfaces;
using TheArchive.Loader;
using TheArchive.Utilities;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Hikaria.ItemMarker
{
	[ArchiveDependency(/*Could not decode attribute arguments.*/)]
	[ArchiveDependency(/*Could not decode attribute arguments.*/)]
	[ArchiveModule("Hikaria.ItemMarker", "ItemMarker", "1.1.0")]
	public class EntryPoint : IArchiveModule
	{
		public ILocalizationService LocalizationService { get; set; }

		public IArchiveLogger Logger { get; set; }

		public void Init()
		{
			Logs.Setup(Logger);
		}
	}
	internal static class Logs
	{
		private static IArchiveLogger _logger;

		public static void Setup(IArchiveLogger logger)
		{
			_logger = logger;
		}

		public static void LogDebug(object data)
		{
			_logger.Debug(data.ToString());
		}

		public static void LogError(object data)
		{
			_logger.Error(data.ToString());
		}

		public static void LogInfo(object data)
		{
			_logger.Info(data.ToString());
		}

		public static void LogMessage(object data)
		{
			_logger.Msg(ConsoleColor.White, data.ToString());
		}

		public static void LogWarning(object data)
		{
			_logger.Warning(data.ToString());
		}

		public static void LogNotice(object data)
		{
			_logger.Notice(data.ToString());
		}

		public static void LogSuccess(object data)
		{
			_logger.Success(data.ToString());
		}

		public static void LogException(Exception ex)
		{
			_logger.Exception(ex);
		}
	}
	public static class PluginInfo
	{
		public const string GUID = "Hikaria.ItemMarker";

		public const string NAME = "ItemMarker";

		public const string VERSION = "1.1.0";
	}
}
namespace Hikaria.ItemMarker.Managers
{
	public static class IconManager
	{
		private static Dictionary<string, Sprite> _customItemIconSprites = new Dictionary<string, Sprite>();

		private static Dictionary<string, Texture2D> _customItemIconTextures = new Dictionary<string, Texture2D>();

		public static bool TryGetCustomIcon(string fileName, out Sprite sprite)
		{
			return _customItemIconSprites.TryGetValue(fileName, out sprite);
		}

		internal static void Init()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Assets/icons");
			if (!Directory.Exists(path))
			{
				Directory.CreateDirectory(path);
			}
			string[] files = Directory.GetFiles(path, "*.png");
			foreach (string path2 in files)
			{
				string fileName = Path.GetFileName(path2);
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path2);
				byte[] array = File.ReadAllBytes(path2);
				Texture2D val = new Texture2D(2, 2);
				if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array)))
				{
					((Object)val).name = fileNameWithoutExtension;
					((Object)val).hideFlags = (HideFlags)61;
					_customItemIconTextures[fileName] = val;
					Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 64f);
					((Object)val2).name = Path.GetFileNameWithoutExtension(path2);
					((Object)val2).hideFlags = (HideFlags)61;
					_customItemIconSprites[fileName] = val2;
				}
			}
		}
	}
	public static class ItemMarkerManager
	{
		[CompilerGenerated]
		private sealed class <UpdateDevMode>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ItemMarkerBase marker;

			private WaitForSecondsRealtime <yielder>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateDevMode>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<yielder>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<yielder>5__2 = new WaitForSecondsRealtime(0.2f);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (DevMode)
				{
					try
					{
						marker.DoDevModeUpdate();
					}
					catch
					{
					}
					<>2__current = <yielder>5__2;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static bool _devMode;

		private static readonly Dictionary<Type, Type> _itemMarkers = new Dictionary<Type, Type>();

		private static readonly HashSet<Type> _typesToInspect = new HashSet<Type>();

		private static readonly Dictionary<int, HashSet<ItemMarkerBase>> _terminalItemMarkers = new Dictionary<int, HashSet<ItemMarkerBase>>();

		private static readonly HashSet<ItemMarkerBase> _allItemMarkers = new HashSet<ItemMarkerBase>();

		private static readonly Dictionary<ItemMarkerVisibleUpdateModeType, HashSet<ItemMarkerBase>> ItemMarkerAutoUpdateModeLookup = new Dictionary<ItemMarkerVisibleUpdateModeType, HashSet<ItemMarkerBase>>
		{
			{
				ItemMarkerVisibleUpdateModeType.World,
				new HashSet<ItemMarkerBase>()
			},
			{
				ItemMarkerVisibleUpdateModeType.CourseNode,
				new HashSet<ItemMarkerBase>()
			},
			{
				ItemMarkerVisibleUpdateModeType.Zone,
				new HashSet<ItemMarkerBase>()
			},
			{
				ItemMarkerVisibleUpdateModeType.Dimension,
				new HashSet<ItemMarkerBase>()
			},
			{
				ItemMarkerVisibleUpdateModeType.Manual,
				new HashSet<ItemMarkerBase>()
			},
			{
				ItemMarkerVisibleUpdateModeType.Custom,
				new HashSet<ItemMarkerBase>()
			}
		};

		public static bool DevMode
		{
			get
			{
				return _devMode;
			}
			set
			{
				if (_devMode == value)
				{
					return;
				}
				_devMode = value;
				if (_devMode)
				{
					foreach (ItemMarkerBase allItemMarker in _allItemMarkers)
					{
						allItemMarker.DoEnterDevMode();
						if (!((Behaviour)allItemMarker).enabled)
						{
							CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(UpdateDevMode(allItemMarker)), (Action)null);
						}
					}
					return;
				}
				foreach (ItemMarkerBase allItemMarker2 in _allItemMarkers)
				{
					allItemMarker2.DoExitDevMode();
				}
			}
		}

		[IteratorStateMachine(typeof(<UpdateDevMode>d__4))]
		private static IEnumerator UpdateDevMode(ItemMarkerBase marker)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateDevMode>d__4(0)
			{
				marker = marker
			};
		}

		internal static void Init()
		{
			ClassInjector.RegisterTypeInIl2Cpp<ItemMarkerTag>(false);
			ClassInjector.RegisterTypeInIl2Cpp<ItemScanner>(false);
			ClassInjector.RegisterTypeInIl2Cpp<ItemInLevel_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_ComputerTerminal_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_PowerGenerator_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_HSU_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_HSUActivator_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_BulkheadDoorController_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_SecurityDoor_Locks_Marker>(false);
			ClassInjector.RegisterTypeInIl2Cpp<LG_DisinfectionStation_Marker>(false);
		}

		internal static void SearchGameObject()
		{
			foreach (Type item in _typesToInspect)
			{
				foreach (Object item2 in (Il2CppArrayBase<Object>)(object)Object.FindObjectsOfType(item))
				{
					Component val = ((Il2CppObjectBase)item2).Cast<Component>();
					if ((Object)(object)val.GetComponent<ItemMarkerBase>() == (Object)null)
					{
						((Il2CppObjectBase)val.gameObject.AddComponent(_itemMarkers[item])).Cast<ItemMarkerBase>().SetupNavMarker(val);
					}
				}
			}
		}

		public static void RegisterItemMarker<C, T>() where C : Component where T : ItemMarkerBase
		{
			Type val = Il2CppType.Of<C>(true);
			_typesToInspect.Add(val);
			ClassInjector.RegisterTypeInIl2Cpp<T>(false);
			_itemMarkers.Add(val, Il2CppType.Of<T>(true));
		}

		internal static void RegisterItemMarker(ItemMarkerBase marker)
		{
			_allItemMarkers.Add(marker);
			if (DevMode)
			{
				marker.DoEnterDevMode();
			}
			if (!((Behaviour)marker).enabled)
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(UpdateDevMode(marker)), (Action)null);
			}
		}

		internal static void UnregisterItemMarker(ItemMarkerBase marker)
		{
			_allItemMarkers.Remove(marker);
		}

		internal static void RegisterTerminalItemMarker(int instanceId, ItemMarkerBase marker)
		{
			if (!_terminalItemMarkers.TryGetValue(instanceId, out var value))
			{
				value = new HashSet<ItemMarkerBase>();
				_terminalItemMarkers[instanceId] = value;
			}
			value.Add(marker);
		}

		internal static void UnregisterTerminalItemMarker(int instanceId, ItemMarkerBase marker)
		{
			if (_terminalItemMarkers.TryGetValue(instanceId, out var value))
			{
				value.Remove(marker);
				if (value.Count == 0)
				{
					_terminalItemMarkers.Remove(instanceId);
				}
			}
		}

		internal static void OnTerminalPing(int instanceId)
		{
			if (!_terminalItemMarkers.TryGetValue(instanceId, out var value))
			{
				return;
			}
			foreach (ItemMarkerBase item in value)
			{
				item.OnTerminalPing();
			}
		}

		internal static void OnTerminalItemKeyUpdate(int instanceId, string key)
		{
			if (!_terminalItemMarkers.TryGetValue(instanceId, out var value))
			{
				return;
			}
			foreach (ItemMarkerBase item in value)
			{
				item.OnTerminalItemKeyUpdate(key);
			}
		}

		internal static void RegisterItemMarkerAutoUpdate(ItemMarkerBase itemMarker)
		{
			if (ItemMarkerAutoUpdateModeLookup.TryGetValue(itemMarker.VisibleUpdateMode, out var value))
			{
				value.Add(itemMarker);
			}
		}

		internal static void UnregisterItemMarkerAutoUpdate(ItemMarkerBase itemMarker)
		{
			if (ItemMarkerAutoUpdateModeLookup.TryGetValue(itemMarker.VisibleUpdateMode, out var value))
			{
				value.Remove(itemMarker);
			}
		}

		internal static void OnPlayerCourseNodeChanged(AIG_CourseNode newNode)
		{
			if (DevMode)
			{
				foreach (ItemMarkerBase allItemMarker in _allItemMarkers)
				{
					allItemMarker.DoDevModeUpdate();
				}
				return;
			}
			foreach (ItemMarkerBase item in ItemMarkerAutoUpdateModeLookup[ItemMarkerVisibleUpdateModeType.CourseNode])
			{
				item.OnPlayerCourseNodeChanged(newNode);
			}
		}

		internal static void OnPlayerZoneChanged(LG_Zone newZone)
		{
			if (DevMode)
			{
				foreach (ItemMarkerBase allItemMarker in _allItemMarkers)
				{
					allItemMarker.DoDevModeUpdate();
				}
				return;
			}
			foreach (ItemMarkerBase item in ItemMarkerAutoUpdateModeLookup[ItemMarkerVisibleUpdateModeType.Zone])
			{
				item.OnPlayerZoneChanged(newZone);
			}
		}

		internal static void OnPlayerDimensionChanged(Dimension newDim)
		{
			if (DevMode)
			{
				foreach (ItemMarkerBase allItemMarker in _allItemMarkers)
				{
					allItemMarker.DoDevModeUpdate();
				}
				return;
			}
			foreach (ItemMarkerBase item in ItemMarkerAutoUpdateModeLookup[ItemMarkerVisibleUpdateModeType.Dimension])
			{
				item.OnPlayerDimensionChanged(newDim);
			}
		}
	}
}
namespace Hikaria.ItemMarker.Handlers
{
	public abstract class ItemMarkerBase : MonoBehaviour
	{
		protected struct pBasicState
		{
			public bool IsDiscovered;

			public bool IsVisible;
		}

		[CompilerGenerated]
		private sealed class <HideDelay>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

			public ItemMarkerBase <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HideDelay>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Expected O, but got Unknown
				int num = <>1__state;
				ItemMarkerBase itemMarkerBase = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSecondsRealtime(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					itemMarkerBase.ForceUpdate();
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <UpdateMarkerAlphaCoroutine>d__26 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ItemMarkerBase <>4__this;

			private WaitForFixedUpdate <yielder>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <UpdateMarkerAlphaCoroutine>d__26(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<yielder>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				int num = <>1__state;
				ItemMarkerBase itemMarkerBase = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<yielder>5__2 = new WaitForFixedUpdate();
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)itemMarkerBase.m_marker != (Object)null)
				{
					itemMarkerBase.UpdateMarkerAlpha();
					<>2__current = <yielder>5__2;
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		protected bool m_discoverOnPlayerPing = true;

		protected bool m_discoverOnTerminalPing;

		protected bool m_markerAlwaysShowTitle;

		protected bool m_markerAlwaysShowDistance;

		protected float m_markerPlayerPingFadeOutTime = 12f;

		protected float m_markerTerminalPingFadeOutTime = 18f;

		protected ItemMarkerVisibleUpdateModeType m_markerVisibleUpdateMode;

		protected float m_markerVisibleWorldDistance = 30f;

		protected int m_markerVisibleCourseNodeDistance = 1;

		protected float m_markerAlpha = 0.9f;

		protected float m_markerAlphaADS = 0.4f;

		protected Color m_markerColor = Color.white;

		protected string m_markerTitle = string.Empty;

		protected eNavMarkerStyle m_markerStyle;

		protected float m_markerIconScale = 0.4f;

		protected int m_markerTitleFontSize = 50;

		protected bool m_markerTitleUseTerminalItemKey;

		protected bool m_overridePlayerPing = true;

		protected bool m_markerShowPin;

		protected LG_GenericTerminalItem m_terminalItem;

		protected NavMarker m_marker;

		protected float m_updateTimer;

		protected float m_markerForceVisibleTimer;

		protected NavMarkerOption[] m_stateOptions;

		protected readonly Dictionary<eBufferType, pBasicState> m_basicBuffers = new Dictionary<eBufferType, pBasicState>();

		private PlayerAgent m_localPlayer;

		private bool m_isDiscovered;

		[HideFromIl2Cpp]
		public bool IsDiscovered
		{
			get
			{
				return m_isDiscovered;
			}
			set
			{
				m_isDiscovered = value;
				ForceUpdate();
			}
		}

		[HideFromIl2Cpp]
		private bool AimButtonHeld
		{
			get
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Invalid comparison between Unknown and I4
				//IL_0032: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Invalid comparison between Unknown and I4
				if ((Object)(object)LocalPlayerAgent == (Object)null || !((Agent)LocalPlayerAgent).Alive)
				{
					return false;
				}
				InventorySlot wieldedSlot = LocalPlayerAgent.Inventory.WieldedSlot;
				if ((int)wieldedSlot < 1 || (int)wieldedSlot > 3)
				{
					return false;
				}
				ItemEquippable wieldedItem = LocalPlayerAgent.Inventory.WieldedItem;
				if (wieldedItem == null)
				{
					return false;
				}
				return wieldedItem.AimButtonHeld;
			}
		}

		[HideFromIl2Cpp]
		public PlayerAgent LocalPlayerAgent
		{
			get
			{
				if ((Object)(object)m_localPlayer == (Object)null)
				{
					m_localPlayer = PlayerManager.GetLocalPlayerAgent();
				}
				return m_localPlayer;
			}
		}

		[HideFromIl2Cpp]
		public virtual bool AllowDiscoverScan => !m_isDiscovered;

		[HideFromIl2Cpp]
		public virtual AIG_CourseNode CourseNode
		{
			get
			{
				LG_GenericTerminalItem terminalItem = m_terminalItem;
				if (terminalItem == null)
				{
					return null;
				}
				return terminalItem.SpawnNode;
			}
		}

		[HideFromIl2Cpp]
		public virtual Vector3 WorldPos => m_marker.m_trackingObj.transform.position;

		[HideFromIl2Cpp]
		public bool IsVisible => m_marker.IsVisible;

		[HideFromIl2Cpp]
		public bool IsVisibleAndInFocus
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Invalid comparison between Unknown and I4
				if (m_marker.IsVisible)
				{
					return (int)m_marker.m_currentState == 2;
				}
				return false;
			}
		}

		[HideFromIl2Cpp]
		public eNavMarkerStyle Style => m_markerStyle;

		[HideFromIl2Cpp]
		public bool AllowPing => m_markerShowPin;

		[HideFromIl2Cpp]
		public float PlayerPingFadeOutTime => m_markerPlayerPingFadeOutTime;

		[HideFromIl2Cpp]
		public float TerminalPingFadeOutTime => m_markerTerminalPingFadeOutTime;

		[HideFromIl2Cpp]
		internal ItemMarkerVisibleUpdateModeType VisibleUpdateMode => m_markerVisibleUpdateMode;

		[HideFromIl2Cpp]
		protected virtual string MarkerTitle => m_markerTitle;

		public ItemMarkerBase(IntPtr ptr)
			: base(ptr)
		{
		}//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)


		[HideFromIl2Cpp]
		public virtual void SetupNavMarker(Component comp)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			if (m_marker == null)
			{
				m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			}
			m_marker.SetStyle(m_markerStyle);
			m_marker.SetIconScale(m_markerIconScale);
			m_marker.SetPinEnabled(m_markerShowPin);
			m_marker.SetColor(m_markerColor);
			m_marker.SetAlpha(m_markerAlpha);
			m_marker.SetVisible(false);
			((TMP_Text)m_marker.m_title).fontSizeMax = m_markerTitleFontSize;
			((TMP_Text)m_marker.m_title).fontSizeMin = m_markerTitleFontSize;
			if (m_terminalItem == null)
			{
				m_terminalItem = comp.GetComponentInChildren<LG_GenericTerminalItem>();
			}
			if ((Object)(object)m_terminalItem != (Object)null && m_terminalItem.SpawnNode == null)
			{
				LG_Area componentInParent = ((Component)m_terminalItem).GetComponentInParent<LG_Area>();
				if ((Object)(object)componentInParent != (Object)null)
				{
					m_terminalItem.SpawnNode = componentInParent.m_courseNode;
				}
			}
			if (!string.IsNullOrEmpty(m_markerTitle))
			{
				m_marker.SetTitle(m_markerTitle);
			}
			else if ((Object)(object)m_terminalItem != (Object)null && !string.IsNullOrEmpty(m_terminalItem.TerminalItemKey))
			{
				m_marker.SetTitle(m_terminalItem.TerminalItemKey);
			}
			else
			{
				m_marker.SetTitle(((Object)comp.gameObject).name);
			}
			((TMP_Text)m_marker.m_title).rectTransform.sizeDelta = new Vector2(((TMP_Text)m_marker.m_title).rectTransform.sizeDelta.x * 5f, ((TMP_Text)m_marker.m_title).rectTransform.sizeDelta.y);
			if (m_markerAlwaysShowTitle)
			{
				Il2CppStructArray<NavMarkerOption> stateOptions = m_marker.m_stateOptions;
				((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] = (NavMarkerOption)(((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] | 0x10);
			}
			if (m_markerAlwaysShowDistance)
			{
				Il2CppStructArray<NavMarkerOption> stateOptions = m_marker.m_stateOptions;
				((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] = (NavMarkerOption)(((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] | 8);
			}
			m_stateOptions = Il2CppArrayBase<NavMarkerOption>.op_Implicit((Il2CppArrayBase<NavMarkerOption>)(object)m_marker.m_stateOptions);
			if (m_overridePlayerPing)
			{
				foreach (Collider componentsInChild in comp.GetComponentsInChildren<Collider>(true))
				{
					if ((Object)(object)((Component)componentsInChild).GetComponent<ItemMarkerTag>() == (Object)null)
					{
						((Component)componentsInChild).gameObject.AddComponent<ItemMarkerTag>().Setup(this);
					}
				}
			}
			((Behaviour)this).enabled = m_markerVisibleUpdateMode == ItemMarkerVisibleUpdateModeType.World || m_markerVisibleUpdateMode == ItemMarkerVisibleUpdateModeType.Custom;
			if (!((Behaviour)this).enabled)
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(UpdateMarkerAlphaCoroutine()), (Action)null);
			}
			SNetEventAPI.OnResetSession += OnResetSession;
			SNetEventAPI.OnRecallComplete += OnRecallComplete;
			SNetEventAPI.OnBufferCommand += OnBufferCommand;
			ItemMarkerManager.RegisterItemMarkerAutoUpdate(this);
			if ((Object)(object)m_terminalItem != (Object)null)
			{
				ItemMarkerManager.RegisterTerminalItemMarker(((Object)m_terminalItem).GetInstanceID(), this);
			}
			ItemMarkerManager.RegisterItemMarker(this);
		}

		[HideFromIl2Cpp]
		public virtual bool OnPlayerPing()
		{
			if (!IsDiscovered && m_discoverOnPlayerPing)
			{
				IsDiscovered = true;
			}
			AttemptInteract((eNavMarkerInteractionType)0);
			m_marker.Ping(m_markerPlayerPingFadeOutTime);
			m_markerForceVisibleTimer = Clock.Time + m_markerPlayerPingFadeOutTime;
			if (!((Behaviour)this).enabled)
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(HideDelay(m_markerPlayerPingFadeOutTime + 0.01f)), (Action)null);
			}
			return true;
		}

		[HideFromIl2Cpp]
		public virtual bool OnTerminalPing()
		{
			if (!IsDiscovered && m_discoverOnTerminalPing)
			{
				IsDiscovered = true;
			}
			AttemptInteract((eNavMarkerInteractionType)0);
			m_marker.Ping(m_markerTerminalPingFadeOutTime);
			m_markerForceVisibleTimer = Clock.Time + m_markerTerminalPingFadeOutTime;
			if (!((Behaviour)this).enabled)
			{
				CoroutineManager.StartCoroutine(CollectionExtensions.WrapToIl2Cpp(HideDelay(m_markerTerminalPingFadeOutTime + 0.01f)), (Action)null);
			}
			return true;
		}

		[HideFromIl2Cpp]
		public virtual void OnPlayerCourseNodeChanged(AIG_CourseNode newNode)
		{
			if (IsDiscovered)
			{
				if (newNode == null || CourseNode == null)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else if (AIG_CourseGraph.GetDistanceBetweenToNodes(CourseNode, ((Agent)LocalPlayerAgent).CourseNode) <= m_markerVisibleCourseNodeDistance)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
			}
		}

		[HideFromIl2Cpp]
		public virtual void OnPlayerZoneChanged(LG_Zone newZone)
		{
			if (IsDiscovered)
			{
				if ((Object)(object)newZone == (Object)null || CourseNode == null)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else if (CourseNode.m_zone.ID == newZone.ID)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
			}
		}

		[HideFromIl2Cpp]
		public virtual void OnPlayerDimensionChanged(Dimension newDim)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (IsDiscovered)
			{
				if (newDim == null || CourseNode == null)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else if (CourseNode.m_dimension.DimensionIndex == newDim.DimensionIndex)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
			}
		}

		[HideFromIl2Cpp]
		internal void OnTerminalItemKeyUpdate(string key)
		{
			if (m_markerTitleUseTerminalItemKey)
			{
				m_marker.SetTitle(key);
			}
		}

		[HideFromIl2Cpp]
		public void AttemptInteract(eNavMarkerInteractionType interaction)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if ((int)interaction == 0)
			{
				if (!m_marker.IsVisible)
				{
					m_marker.SetVisible(true);
				}
			}
			else if ((int)interaction == 1 && m_marker.IsVisible)
			{
				m_marker.SetVisible(false);
			}
		}

		protected virtual void Update()
		{
			if ((Object)(object)m_marker == (Object)null || m_updateTimer > Clock.Time)
			{
				return;
			}
			m_updateTimer = Clock.Time + 0.2f;
			if (ItemMarkerManager.DevMode)
			{
				OnDevUpdate();
				return;
			}
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
				return;
			}
			if (!IsDiscovered)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return;
			}
			if ((Object)(object)LocalPlayerAgent == (Object)null)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return;
			}
			switch (m_markerVisibleUpdateMode)
			{
			case ItemMarkerVisibleUpdateModeType.World:
				OnWorldUpdate();
				break;
			case ItemMarkerVisibleUpdateModeType.Custom:
				OnCustomUpdate();
				break;
			}
		}

		[HideFromIl2Cpp]
		protected virtual void OnWorldUpdate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(m_marker.TrackingTrans.position, ((Component)LocalPlayerAgent).transform.position) <= m_markerVisibleWorldDistance)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected virtual void OnCustomUpdate()
		{
		}

		protected virtual void OnDestroy()
		{
			if ((Object)(object)m_marker != (Object)null)
			{
				GuiManager.NavMarkerLayer.RemoveMarker(m_marker);
			}
			SNetEventAPI.OnResetSession -= OnResetSession;
			SNetEventAPI.OnRecallComplete -= OnRecallComplete;
			SNetEventAPI.OnBufferCommand -= OnBufferCommand;
			ItemMarkerManager.UnregisterItemMarkerAutoUpdate(this);
			if ((Object)(object)m_terminalItem != (Object)null)
			{
				ItemMarkerManager.UnregisterTerminalItemMarker(((Object)m_terminalItem).GetInstanceID(), this);
			}
			ItemMarkerManager.UnregisterItemMarker(this);
		}

		protected virtual void FixedUpdate()
		{
			UpdateMarkerAlpha();
		}

		[HideFromIl2Cpp]
		public void ForceUpdate()
		{
			if ((Object)(object)m_marker == (Object)null)
			{
				return;
			}
			UpdateMarkerTitle();
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
				return;
			}
			if (ItemMarkerManager.DevMode)
			{
				OnDevUpdate();
				return;
			}
			if ((Object)(object)LocalPlayerAgent == (Object)null || ((Agent)LocalPlayerAgent).CourseNode == null)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return;
			}
			if (!IsDiscovered)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return;
			}
			switch (m_markerVisibleUpdateMode)
			{
			case ItemMarkerVisibleUpdateModeType.World:
				OnWorldUpdate();
				break;
			case ItemMarkerVisibleUpdateModeType.CourseNode:
				OnPlayerCourseNodeChanged(((Agent)LocalPlayerAgent).CourseNode);
				break;
			case ItemMarkerVisibleUpdateModeType.Zone:
				OnPlayerZoneChanged(LocalPlayerAgent.m_lastEnteredZone);
				break;
			case ItemMarkerVisibleUpdateModeType.Dimension:
				OnPlayerDimensionChanged(((Agent)LocalPlayerAgent).Dimension);
				break;
			case ItemMarkerVisibleUpdateModeType.Manual:
				OnManualUpdate();
				break;
			case ItemMarkerVisibleUpdateModeType.Custom:
				OnCustomUpdate();
				break;
			}
		}

		[HideFromIl2Cpp]
		protected virtual void OnManualUpdate()
		{
		}

		[HideFromIl2Cpp]
		internal void DoDevModeUpdate()
		{
			OnDevUpdate();
		}

		[HideFromIl2Cpp]
		internal void DoEnterDevMode()
		{
			OnEnterDevMode();
		}

		[HideFromIl2Cpp]
		internal void DoExitDevMode()
		{
			OnExitDevMode();
		}

		[HideFromIl2Cpp]
		protected virtual void OnEnterDevMode()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Il2CppStructArray<NavMarkerOption> stateOptions = m_marker.m_stateOptions;
			((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] = (NavMarkerOption)(((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] | 0x10);
			stateOptions = m_marker.m_stateOptions;
			((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] = (NavMarkerOption)(((Il2CppArrayBase<NavMarkerOption>)(object)stateOptions)[1] | 8);
			m_marker.SetState(m_marker.m_currentState);
			ForceUpdate();
		}

		[HideFromIl2Cpp]
		protected virtual void OnExitDevMode()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			m_marker.m_stateOptions = Il2CppStructArray<NavMarkerOption>.op_Implicit(m_stateOptions);
			m_marker.SetState(m_marker.m_currentState);
			ForceUpdate();
		}

		[HideFromIl2Cpp]
		protected virtual void OnDevUpdate()
		{
		}

		[IteratorStateMachine(typeof(<HideDelay>d__25))]
		[HideFromIl2Cpp]
		protected IEnumerator HideDelay(float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HideDelay>d__25(0)
			{
				<>4__this = this,
				delay = delay
			};
		}

		[IteratorStateMachine(typeof(<UpdateMarkerAlphaCoroutine>d__26))]
		[HideFromIl2Cpp]
		private IEnumerator UpdateMarkerAlphaCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateMarkerAlphaCoroutine>d__26(0)
			{
				<>4__this = this
			};
		}

		[HideFromIl2Cpp]
		public void UpdateMarkerTitle()
		{
			m_marker.SetTitle(MarkerTitle);
		}

		[HideFromIl2Cpp]
		public void UpdateMarkerAlpha()
		{
			if (m_marker.IsVisible)
			{
				if (AimButtonHeld)
				{
					m_marker.SetAlpha(m_markerAlphaADS);
				}
				else
				{
					m_marker.SetAlpha(m_markerAlpha);
				}
			}
		}

		[HideFromIl2Cpp]
		public void OnResetSession()
		{
			ResetBuffer();
		}

		[HideFromIl2Cpp]
		protected virtual void ResetBuffer()
		{
			m_basicBuffers.Clear();
		}

		[HideFromIl2Cpp]
		public void OnRecallComplete(eBufferType bufferType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)GameStateManager.CurrentStateName >= 10)
			{
				RecallBuffer(bufferType);
				ForceUpdate();
			}
		}

		[HideFromIl2Cpp]
		protected virtual void CaptureToBuffer(eBufferType bufferType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			m_basicBuffers[bufferType] = new pBasicState
			{
				IsDiscovered = m_isDiscovered,
				IsVisible = m_marker.IsVisible
			};
		}

		[HideFromIl2Cpp]
		protected virtual void RecallBuffer(eBufferType bufferType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (m_basicBuffers.TryGetValue(bufferType, out var value))
			{
				m_marker.SetVisible(value.IsVisible);
				m_isDiscovered = value.IsDiscovered;
			}
		}

		[HideFromIl2Cpp]
		public void OnBufferCommand(pBufferCommand command)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)command.operation == 1)
			{
				CaptureToBuffer(command.type);
			}
		}
	}
	public enum ItemMarkerVisibleUpdateModeType
	{
		World,
		CourseNode,
		Zone,
		Dimension,
		Manual,
		Custom
	}
	public class ItemMarkerTag : MonoBehaviour
	{
		[HideFromIl2Cpp]
		public ItemMarkerBase ItemMarker { get; private set; }

		public ItemMarkerTag(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public void Setup(ItemMarkerBase itemMarker)
		{
			ItemMarker = itemMarker;
		}
	}
	public class ItemScanner : MonoBehaviour
	{
		private bool m_isLocal;

		private PlayerAgent m_playerAgent;

		private Il2CppStructArray<RaycastHit> m_hits = new Il2CppStructArray<RaycastHit>((RaycastHit[])(object)new RaycastHit[30]);

		private int s_collCount;

		public ItemScanner(IntPtr ptr)
			: base(ptr)
		{
		}

		private void Awake()
		{
			m_playerAgent = ((Component)this).GetComponent<PlayerAgent>();
			m_isLocal = ((Agent)m_playerAgent).IsLocallyOwned;
		}

		private void LateUpdate()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (m_isLocal)
			{
				s_collCount = Physics.SphereCastNonAlloc(m_playerAgent.FPSCamera.Position, 3f, m_playerAgent.FPSCamera.CameraRayDir, m_hits, 0f, LayerManager.MASK_PLAYER_INTERACT_SPHERE);
			}
			else
			{
				s_collCount = Physics.SphereCastNonAlloc(((Agent)m_playerAgent).EyePosition, 2.5f, ((Component)m_playerAgent).transform.forward, m_hits, 0.5f, LayerManager.MASK_PLAYER_INTERACT_SPHERE);
			}
			if (s_collCount == 0)
			{
				return;
			}
			for (int i = 0; i < s_collCount; i++)
			{
				RaycastHit val = ((Il2CppArrayBase<RaycastHit>)(object)m_hits)[i];
				ItemMarkerTag component = ((Component)((RaycastHit)(ref val)).collider).GetComponent<ItemMarkerTag>();
				if ((Object)(object)component != (Object)null && component.ItemMarker.AllowDiscoverScan)
				{
					component.ItemMarker.IsDiscovered = true;
				}
			}
		}
	}
}
namespace Hikaria.ItemMarker.Handlers.Markers
{
	public class ItemInLevel_Marker : ItemMarkerBase
	{
		public struct pItemInLevelMarkerState
		{
			public bool IsPlacedInLevel;
		}

		public enum ItemMarkerTitleProviderType
		{
			PublicName,
			TerminalItemKey,
			Custom
		}

		private class ItemInLevelMarkerDefinition
		{
			public uint ItemID { get; set; }

			public bool IgnoreThisItem { get; set; }

			public string DataBlockName { get; set; } = string.Empty;


			public string PublicName { get; set; } = string.Empty;


			public string CustomTitle { get; set; } = string.Empty;


			public ItemMarkerTitleProviderType TitleType { get; set; }

			public SColor Color { get; set; } = SColorExtensions.ToSColor(Color.white);


			public ItemMarkerVisibleUpdateModeType VisibleUpdateMode { get; set; } = ItemMarkerVisibleUpdateModeType.Custom;


			public float VisibleWorldDistance { get; set; } = 30f;


			public int VisibleCourseNodeDistance { get; set; } = 1;


			public float Alpha { get; set; } = 0.9f;


			public float AlphaADS { get; set; } = 0.4f;


			public float PlayerPingFadeOutTime { get; set; } = 12f;


			public float TerminalPingFadeOutTime { get; set; } = 18f;


			public bool AlwaysShowTitle { get; set; }

			public bool AlwaysShowDistance { get; set; }

			public bool UseCustomIcon { get; set; }

			public string CustomIconFileName { get; set; } = string.Empty;

		}

		private ItemInLevel m_item;

		private float m_itemCostOfBullet = 1f;

		private bool m_itemShowUses;

		private int m_itemUsesLeft;

		private InventorySlot m_itemSlot;

		private PlaceNavMarkerOnGO m_navMarkerPlacer;

		private bool m_isPlacedInLevel = true;

		private readonly Dictionary<eBufferType, pItemInLevelMarkerState> m_buffers = new Dictionary<eBufferType, pItemInLevelMarkerState>();

		private static CustomSetting<Dictionary<uint, ItemInLevelMarkerDefinition>> ItemInLevelMarkerDefinitions = new CustomSetting<Dictionary<uint, ItemInLevelMarkerDefinition>>("ItemInLevelMarkerDefinitions", new Dictionary<uint, ItemInLevelMarkerDefinition>(), (Action<Dictionary<uint, ItemInLevelMarkerDefinition>>)null, (LoadingTime)1, true);

		private static readonly InventorySlot[] ValidItemSlots;

		internal static readonly Dictionary<int, ItemInLevel_Marker> ItemInLevelMarkerLookup;

		[HideFromIl2Cpp]
		private bool IsPlacedInLevel
		{
			get
			{
				return m_isPlacedInLevel;
			}
			set
			{
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: 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)
				m_isPlacedInLevel = value;
				PlaceNavMarkerOnGO navMarkerPlacer = m_navMarkerPlacer;
				if (navMarkerPlacer != null)
				{
					NavMarker marker = navMarkerPlacer.m_marker;
					if (marker != null)
					{
						marker.SetVisible(false);
					}
				}
				if (!value)
				{
					m_markerForceVisibleTimer = 0f;
					if (m_marker.m_pingRoutine != null)
					{
						CoroutineManager.StopCoroutine(m_marker.m_pingRoutine);
						m_marker.Scale(m_marker.m_pingObj, m_marker.m_pinStartScale, m_marker.m_pinStartScale, Color.white, Color.white, 0f, (DelEasingFunction)null);
					}
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else
				{
					UpdateItemUsesLeft();
					ForceUpdate();
				}
			}
		}

		[HideFromIl2Cpp]
		protected override string MarkerTitle
		{
			get
			{
				//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_03d8: Expected I4, but got Unknown
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Expected I4, but got Unknown
				//IL_03e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				InventorySlot itemSlot;
				if (ItemMarkerManager.DevMode)
				{
					itemSlot = m_itemSlot;
					switch (itemSlot - 4)
					{
					case 4:
						if (!m_item.internalSync.GetCurrentState().placement.hasBeenPickedUp)
						{
							return $"<color=red>{Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(1u, (string)null)}</color>\n{(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n"))}{m_markerTitle}";
						}
						return (base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n")) + m_markerTitle;
					case 0:
					case 1:
					{
						if (CourseNode != null && (Object)(object)base.LocalPlayerAgent != (Object)null && ((Agent)base.LocalPlayerAgent).CourseNode != null && CourseNode.m_zone.ID != ((Agent)base.LocalPlayerAgent).CourseNode.m_zone.ID)
						{
							if (m_itemShowUses)
							{
								DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(22, 4);
								defaultInterpolatedStringHandler.AppendLiteral("<color=red>");
								defaultInterpolatedStringHandler.AppendFormatted(Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(3u, (string)null));
								defaultInterpolatedStringHandler.AppendLiteral("</color>\n");
								defaultInterpolatedStringHandler.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n"));
								LG_GenericTerminalItem terminalItem2 = m_terminalItem;
								defaultInterpolatedStringHandler.AppendFormatted(((terminalItem2 != null) ? terminalItem2.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
								defaultInterpolatedStringHandler.AppendLiteral(" ×");
								defaultInterpolatedStringHandler.AppendFormatted(m_itemUsesLeft);
								return defaultInterpolatedStringHandler.ToStringAndClear();
							}
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler2 = new DefaultInterpolatedStringHandler(20, 3);
							defaultInterpolatedStringHandler2.AppendLiteral("<color=red>");
							defaultInterpolatedStringHandler2.AppendFormatted(Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(3u, (string)null));
							defaultInterpolatedStringHandler2.AppendLiteral("</color>\n");
							defaultInterpolatedStringHandler2.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n"));
							LG_GenericTerminalItem terminalItem3 = m_terminalItem;
							defaultInterpolatedStringHandler2.AppendFormatted(((terminalItem3 != null) ? terminalItem3.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
							return defaultInterpolatedStringHandler2.ToStringAndClear();
						}
						if (m_itemShowUses)
						{
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler3 = new DefaultInterpolatedStringHandler(2, 3);
							defaultInterpolatedStringHandler3.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n"));
							LG_GenericTerminalItem terminalItem4 = m_terminalItem;
							defaultInterpolatedStringHandler3.AppendFormatted(((terminalItem4 != null) ? terminalItem4.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
							defaultInterpolatedStringHandler3.AppendLiteral(" ×");
							defaultInterpolatedStringHandler3.AppendFormatted(m_itemUsesLeft);
							return defaultInterpolatedStringHandler3.ToStringAndClear();
						}
						string obj = (base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2u, (string)null) + "</color>\n"));
						LG_GenericTerminalItem terminalItem5 = m_terminalItem;
						return obj + (((terminalItem5 != null) ? terminalItem5.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
					}
					case 3:
					case 5:
					{
						LG_GenericTerminalItem terminalItem = m_terminalItem;
						return ((terminalItem != null) ? terminalItem.TerminalItemKey : null) ?? ((Item)m_item).PublicName;
					}
					default:
						return m_markerTitle;
					}
				}
				itemSlot = m_itemSlot;
				switch (itemSlot - 4)
				{
				case 4:
					if (!m_item.internalSync.GetCurrentState().placement.hasBeenPickedUp)
					{
						return "<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(1u, (string)null) + "</color>\n" + m_markerTitle;
					}
					return m_markerTitle;
				case 0:
				case 1:
					if (m_itemShowUses)
					{
						return $"{m_markerTitle} ×{m_itemUsesLeft}";
					}
					return m_markerTitle;
				case 3:
				case 5:
				{
					LG_GenericTerminalItem terminalItem6 = m_terminalItem;
					return ((terminalItem6 != null) ? terminalItem6.TerminalItemKey : null) ?? ((Item)m_item).PublicName;
				}
				default:
					return m_markerTitle;
				}
			}
		}

		[HideFromIl2Cpp]
		public override AIG_CourseNode CourseNode => m_item.CourseNode;

		[HideFromIl2Cpp]
		public override bool AllowDiscoverScan
		{
			get
			{
				if (base.AllowDiscoverScan)
				{
					return (Object)(object)m_item.container == (Object)null;
				}
				return false;
			}
		}

		public ItemInLevel_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_001e: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: 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_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Invalid comparison between Unknown and I4
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Invalid comparison between Unknown and I4
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got I4
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Invalid comparison between Unknown and I4
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106->IL0106: Incompatible stack types: O vs I4
			//IL_0101->IL0106: Incompatible stack types: I4 vs O
			//IL_0101->IL0106: Incompatible stack types: O vs I4
			m_item = ((Il2CppObjectBase)comp).Cast<ItemInLevel>();
			ItemDataBlock itemDataBlock = ((Item)m_item).ItemDataBlock;
			if (!ValidItemSlots.Contains(itemDataBlock.inventorySlot))
			{
				Object.Destroy((Object)(object)this);
				return;
			}
			m_item.internalSync.OnSyncStateChange += Action<ePickupItemStatus, pPickupPlacement, PlayerAgent, bool>.op_Implicit((Action<ePickupItemStatus, pPickupPlacement, PlayerAgent, bool>)OnItemStateChange);
			m_navMarkerPlacer = ((Component)m_item).GetComponent<PlaceNavMarkerOnGO>();
			m_itemSlot = itemDataBlock.inventorySlot;
			m_itemShowUses = !itemDataBlock.GUIShowAmmoInfinite && itemDataBlock.GUIShowAmmoTotalRel;
			m_markerShowPin = true;
			AmmoType ammoTypeFromSlot = PlayerAmmoStorage.GetAmmoTypeFromSlot(itemDataBlock.inventorySlot);
			if ((int)ammoTypeFromSlot != 3)
			{
				if ((int)ammoTypeFromSlot == 5)
				{
					m_itemCostOfBullet = 1f;
					if ((float)itemDataBlock.ConsumableAmmoMax == m_itemCostOfBullet)
					{
						m_itemShowUses = false;
					}
				}
				else
				{
					m_itemShowUses = false;
				}
			}
			else
			{
				m_itemCostOfBullet = 20f;
			}
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(((Component)m_item).gameObject);
			object obj = this;
			iPlayerPingTarget componentInChildren = ((Component)this).GetComponentInChildren<iPlayerPingTarget>();
			int num;
			if (componentInChildren != null)
			{
				obj = componentInChildren.PingTargetStyle;
				num = (int)obj;
			}
			else
			{
				num = 0;
				obj = num;
				num = (int)obj;
			}
			((ItemMarkerBase)num).m_markerStyle = (eNavMarkerStyle)obj;
			m_markerTitle = itemDataBlock.publicName;
			m_terminalItem = ((Component)m_item).GetComponentInChildren<LG_GenericTerminalItem>();
			if (ItemInLevelMarkerDefinitions.Value.TryGetValue(((GameDataBlockBase<ItemDataBlock>)(object)itemDataBlock).persistentID, out var value))
			{
				if (value.IgnoreThisItem)
				{
					Object.Destroy((Object)(object)this);
					return;
				}
				m_markerColor = SColorExtensions.ToUnityColor(value.Color);
				m_markerTitle = value.CustomTitle;
				switch (value.TitleType)
				{
				case ItemMarkerTitleProviderType.PublicName:
					m_markerTitle = ((Item)m_item).PublicName;
					break;
				case ItemMarkerTitleProviderType.TerminalItemKey:
					m_markerTitleUseTerminalItemKey = true;
					if ((Object)(object)m_terminalItem != (Object)null)
					{
						m_markerTitle = m_terminalItem.TerminalItemKey;
					}
					break;
				case ItemMarkerTitleProviderType.Custom:
					m_markerTitle = value.CustomTitle;
					break;
				}
				m_markerVisibleUpdateMode = value.VisibleUpdateMode;
				m_markerVisibleWorldDistance = value.VisibleWorldDistance;
				m_markerVisibleCourseNodeDistance = value.VisibleCourseNodeDistance;
				m_markerAlpha = value.Alpha;
				m_markerAlphaADS = value.AlphaADS;
				m_markerAlwaysShowTitle = value.AlwaysShowTitle;
				m_markerAlwaysShowDistance = value.AlwaysShowDistance;
				m_markerPlayerPingFadeOutTime = value.PlayerPingFadeOutTime;
				m_markerTerminalPingFadeOutTime = value.TerminalPingFadeOutTime;
				if (value.UseCustomIcon && IconManager.TryGetCustomIcon(value.CustomIconFileName, out var sprite))
				{
					foreach (SpriteRenderer componentsInChild in ((Component)m_marker.m_iconHolder).GetComponentsInChildren<SpriteRenderer>(true))
					{
						componentsInChild.sprite = sprite;
					}
				}
			}
			ItemInLevelMarkerLookup[((Object)m_item).GetInstanceID()] = this;
			base.SetupNavMarker(comp);
			if ((int)m_itemSlot == 8)
			{
				UpdateMarkerTitle();
			}
			GameEventAPI.OnGameStateChanged += OnGameStateChanged;
		}

		protected override void Update()
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				base.Update();
			}
		}

		protected override void OnDestroy()
		{
			ItemInLevelMarkerLookup.Remove(((Object)m_item).GetInstanceID());
			base.OnDestroy();
			GameEventAPI.OnGameStateChanged -= OnGameStateChanged;
		}

		[HideFromIl2Cpp]
		public void OnItemStateChange(ePickupItemStatus status, pPickupPlacement placement, PlayerAgent playerAgent, bool isRecall)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			if ((int)status == 0)
			{
				IsPlacedInLevel = true;
			}
			else if ((int)status == 1)
			{
				if (!base.IsDiscovered)
				{
					base.IsDiscovered = true;
				}
				IsPlacedInLevel = false;
			}
		}

		[HideFromIl2Cpp]
		public void OnItemCustomDataUpdate(pItemData_Custom custom)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			UpdateItemUsesLeft();
			if ((int)m_itemSlot == 8 && custom.byteState > 0)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		public override bool OnPlayerPing()
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return true;
			}
			return base.OnPlayerPing();
		}

		[HideFromIl2Cpp]
		public override bool OnTerminalPing()
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return true;
			}
			return base.OnTerminalPing();
		}

		[HideFromIl2Cpp]
		protected override void OnCustomUpdate()
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (IsPlacedInLevel)
			{
				if (CourseNode == null)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else if (CourseNode.m_zone.ID == ((Agent)base.LocalPlayerAgent).CourseNode.m_zone.ID)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else if (Vector3.Distance(m_marker.TrackingTrans.position, ((Component)base.LocalPlayerAgent).transform.position) <= m_markerVisibleWorldDistance)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
			}
		}

		[HideFromIl2Cpp]
		protected override void OnWorldUpdate()
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				base.OnWorldUpdate();
			}
		}

		[HideFromIl2Cpp]
		public override void OnPlayerCourseNodeChanged(AIG_CourseNode newNode)
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				base.OnPlayerCourseNodeChanged(newNode);
			}
		}

		[HideFromIl2Cpp]
		public override void OnPlayerZoneChanged(LG_Zone newZone)
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				base.OnPlayerZoneChanged(newZone);
			}
		}

		[HideFromIl2Cpp]
		public override void OnPlayerDimensionChanged(Dimension newDim)
		{
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				base.OnPlayerDimensionChanged(newDim);
			}
		}

		[HideFromIl2Cpp]
		private void OnGameStateChanged(eGameStateName preState, eGameStateName nextState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			if ((int)nextState == 10)
			{
				UpdateItemUsesLeft();
			}
		}

		[HideFromIl2Cpp]
		private void UpdateItemUsesLeft()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (m_itemShowUses)
			{
				m_itemUsesLeft = Mathf.FloorToInt(((Item)m_item).GetCustomData().ammo / m_itemCostOfBullet);
				UpdateMarkerTitle();
			}
		}

		[HideFromIl2Cpp]
		protected override void OnEnterDevMode()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)m_itemSlot == 8)
			{
				PlaceNavMarkerOnGO navMarkerPlacer = m_navMarkerPlacer;
				if (navMarkerPlacer != null)
				{
					NavMarker marker = navMarkerPlacer.m_marker;
					if (marker != null)
					{
						marker.SetVisible(false);
					}
				}
			}
			base.OnEnterDevMode();
		}

		[HideFromIl2Cpp]
		protected override void OnExitDevMode()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			if ((int)m_itemSlot == 8)
			{
				PlaceNavMarkerOnGO navMarkerPlacer = m_navMarkerPlacer;
				if (navMarkerPlacer != null)
				{
					NavMarker marker = navMarkerPlacer.m_marker;
					if (marker != null)
					{
						marker.SetVisible(false);
					}
				}
			}
			base.OnExitDevMode();
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected I4, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
				return;
			}
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
				return;
			}
			UpdateMarkerTitle();
			if ((Object)(object)base.LocalPlayerAgent == (Object)null || ((Agent)base.LocalPlayerAgent).CourseNode == null || CourseNode == null)
			{
				return;
			}
			InventorySlot itemSlot = m_itemSlot;
			switch (itemSlot - 4)
			{
			case 4:
			{
				PlaceNavMarkerOnGO navMarkerPlacer = m_navMarkerPlacer;
				if (navMarkerPlacer != null)
				{
					NavMarker marker = navMarkerPlacer.m_marker;
					if (marker != null)
					{
						marker.SetVisible(false);
					}
				}
				if (((Item)m_item).GetCustomData().byteState > 0)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else if (!((Il2CppObjectBase)m_item).Cast<CarryItemPickup_Core>().IsInteractable)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				break;
			}
			case 0:
			case 1:
				if (CourseNode.m_zone.ID == ((Agent)base.LocalPlayerAgent).CourseNode.m_zone.ID)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else if (Vector3.Distance(((Component)m_item).transform.position, ((Component)base.LocalPlayerAgent).transform.position) <= m_markerVisibleWorldDistance)
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				break;
			case 3:
			case 5:
				if (!((Object)(object)((Il2CppObjectBase)m_item).TryCast<KeyItemPickup_Core>() != (Object)null) && CourseNode.m_zone.ID != ((Agent)base.LocalPlayerAgent).CourseNode.m_zone.ID)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
				}
				else
				{
					AttemptInteract((eNavMarkerInteractionType)0);
				}
				break;
			default:
				AttemptInteract((eNavMarkerInteractionType)1);
				break;
			}
		}

		[HideFromIl2Cpp]
		protected override void CaptureToBuffer(eBufferType bufferType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			base.CaptureToBuffer(bufferType);
			m_buffers[bufferType] = new pItemInLevelMarkerState
			{
				IsPlacedInLevel = IsPlacedInLevel
			};
		}

		[HideFromIl2Cpp]
		protected override void RecallBuffer(eBufferType bufferType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			base.RecallBuffer(bufferType);
			if (!m_buffers.TryGetValue(bufferType, out var value))
			{
				IsPlacedInLevel = (int)m_item.internalSync.GetCurrentState().status == 0;
			}
			else
			{
				IsPlacedInLevel = value.IsPlacedInLevel;
			}
			if (!base.IsDiscovered && m_item.internalSync.GetCurrentState().placement.hasBeenPickedUp)
			{
				base.IsDiscovered = true;
			}
		}

		[HideFromIl2Cpp]
		protected override void ResetBuffer()
		{
			base.ResetBuffer();
			m_buffers.Clear();
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if ((int)m_itemSlot == 8)
			{
				PlaceNavMarkerOnGO navMarkerPlacer = m_navMarkerPlacer;
				if (navMarkerPlacer != null)
				{
					NavMarker marker = navMarkerPlacer.m_marker;
					if (marker != null)
					{
						marker.SetVisible(false);
					}
				}
				UpdateMarkerTitle();
				if (((Item)m_item).GetCustomData().byteState > 0)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
					return;
				}
				if (!((Il2CppObjectBase)m_item).Cast<CarryItemPickup_Core>().IsInteractable)
				{
					AttemptInteract((eNavMarkerInteractionType)1);
					return;
				}
			}
			if (!IsPlacedInLevel)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
		}

		[HideFromIl2Cpp]
		internal static void OnGameDataInitialized()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: 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_009e: Invalid comparison between Unknown and I4
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//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_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected I4, but got Unknown
			foreach (ItemDataBlock allBlock in GameDataBlockBase<ItemDataBlock>.GetAllBlocks())
			{
				if (!ValidItemSlots.Contains(allBlock.inventorySlot))
				{
					continue;
				}
				if (!ItemInLevelMarkerDefinitions.Value.TryGetValue(((GameDataBlockBase<ItemDataBlock>)(object)allBlock).persistentID, out var value))
				{
					ItemInLevelMarkerDefinition itemInLevelMarkerDefinition = new ItemInLevelMarkerDefinition();
					itemInLevelMarkerDefinition.ItemID = ((GameDataBlockBase<ItemDataBlock>)(object)allBlock).persistentID;
					itemInLevelMarkerDefinition.DataBlockName = ((GameDataBlockBase<ItemDataBlock>)(object)allBlock).name;
					itemInLevelMarkerDefinition.PublicName = allBlock.publicName;
					itemInLevelMarkerDefinition.CustomTitle = allBlock.publicName;
					itemInLevelMarkerDefinition.VisibleUpdateMode = GetDefaultUpdateModeForSlot(allBlock.inventorySlot);
					itemInLevelMarkerDefinition.AlwaysShowTitle = (int)allBlock.inventorySlot == 8;
					itemInLevelMarkerDefinition.AlwaysShowDistance = (int)allBlock.inventorySlot == 8;
					ItemInLevelMarkerDefinition itemInLevelMarkerDefinition2 = itemInLevelMarkerDefinition;
					InventorySlot inventorySlot = allBlock.inventorySlot;
					ItemMarkerTitleProviderType titleType;
					switch (inventorySlot - 7)
					{
					case 1:
						titleType = ItemMarkerTitleProviderType.PublicName;
						break;
					case 0:
					case 2:
						titleType = ItemMarkerTitleProviderType.TerminalItemKey;
						break;
					default:
						titleType = ItemMarkerTitleProviderType.PublicName;
						break;
					}
					itemInLevelMarkerDefinition2.TitleType = titleType;
					value = itemInLevelMarkerDefinition;
					ItemInLevelMarkerDefinitions.Value[((GameDataBlockBase<ItemDataBlock>)(object)allBlock).persistentID] = value;
				}
				else
				{
					value.DataBlockName = ((GameDataBlockBase<ItemDataBlock>)(object)allBlock).name;
					value.ItemID = ((GameDataBlockBase<ItemDataBlock>)(object)allBlock).persistentID;
					value.PublicName = allBlock.publicName;
				}
			}
		}

		[HideFromIl2Cpp]
		private static ItemMarkerVisibleUpdateModeType GetDefaultUpdateModeForSlot(InventorySlot slot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			switch (slot - 4)
			{
			case 0:
			case 1:
				return ItemMarkerVisibleUpdateModeType.Custom;
			case 3:
			case 5:
				return ItemMarkerVisibleUpdateModeType.Zone;
			case 4:
				return ItemMarkerVisibleUpdateModeType.Manual;
			default:
				return ItemMarkerVisibleUpdateModeType.World;
			}
		}

		static ItemInLevel_Marker()
		{
			InventorySlot[] array = new InventorySlot[5];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			ValidItemSlots = (InventorySlot[])(object)array;
			ItemInLevelMarkerLookup = new Dictionary<int, ItemInLevel_Marker>();
		}
	}
	public class LG_BulkheadDoorController_Marker : ItemMarkerBase
	{
		private LG_BulkheadDoorController_Core m_bulkDc;

		public LG_BulkheadDoorController_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			m_bulkDc = ((Il2CppObjectBase)comp).Cast<LG_BulkheadDoorController_Core>();
			m_bulkDc.OnStateChangeCallback += Action<eBulkheadDCStatus, eBulkheadDCStatus>.op_Implicit((Action<eBulkheadDCStatus, eBulkheadDCStatus>)OnStateChangeCallback);
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = new Color(0.573f, 0.663f, 0.718f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_markerStyle = (eNavMarkerStyle)30;
			m_terminalItem = ((Il2CppObjectBase)m_bulkDc.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		private void OnStateChangeCallback(eBulkheadDCStatus oldState, eBulkheadDCStatus newState)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)newState == 3)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			if ((int)m_bulkDc.m_stateReplicator.State.status == 3)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				OnManualUpdate();
			}
		}
	}
	public class LG_ComputerTerminal_Marker : ItemMarkerBase
	{
		private LG_ComputerTerminal m_terminal;

		public LG_ComputerTerminal_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_0017: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = Color.green;
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Zone;
			m_terminal = ((Il2CppObjectBase)comp).Cast<LG_ComputerTerminal>();
			m_terminalItem = ((Il2CppObjectBase)m_terminal.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerStyle = (eNavMarkerStyle)6;
			m_markerAlwaysShowTitle = true;
			m_markerAlwaysShowDistance = true;
			m_markerShowPin = true;
			foreach (Collider componentsInChild in comp.GetComponentsInChildren<Collider>(true))
			{
				if ((Object)(object)((Component)componentsInChild).GetComponent<PlayerPingTarget>() == (Object)null)
				{
					((Component)componentsInChild).gameObject.AddComponent<PlayerPingTarget>().m_pingTargetStyle = (eNavMarkerStyle)6;
				}
			}
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
				return;
			}
			PlayerAgent localPlayerAgent = base.LocalPlayerAgent;
			object obj;
			if (localPlayerAgent == null)
			{
				obj = null;
			}
			else
			{
				AIG_CourseNode courseNode = ((Agent)localPlayerAgent).CourseNode;
				obj = ((courseNode != null) ? courseNode.m_zone : null);
			}
			LG_Zone val = (LG_Zone)obj;
			if ((Object)(object)val == (Object)null)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else if (CourseNode.m_zone.ID == val.ID)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}
	}
	public class LG_DisinfectionStation_Marker : ItemMarkerBase
	{
		private LG_DisinfectionStation m_station;

		public LG_DisinfectionStation_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			m_station = ((Il2CppObjectBase)comp).Cast<LG_DisinfectionStation>();
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = new Color(0.49f, 0.77f, 0.78f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_markerStyle = (eNavMarkerStyle)17;
			m_terminalItem = ((Il2CppObjectBase)m_station.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			if (((Interact_Base)m_station.m_interact).IsActive)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				OnManualUpdate();
			}
		}
	}
	public class LG_HSUActivator_Marker : ItemMarkerBase
	{
		private LG_HSUActivator_Core m_hsuActivator;

		public LG_HSUActivator_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			m_hsuActivator = ((Il2CppObjectBase)comp).Cast<LG_HSUActivator_Core>();
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = new Color(0.467f, 0.098f, 1f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_markerStyle = (eNavMarkerStyle)16;
			m_terminalItem = ((Il2CppObjectBase)m_hsuActivator.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			if (((Behaviour)((Il2CppObjectBase)m_hsuActivator.m_insertHSUInteraction).Cast<LG_GenericCarryItemInteractionTarget>()).isActiveAndEnabled)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				OnManualUpdate();
			}
		}
	}
	public class LG_HSU_Marker : ItemMarkerBase
	{
		private LG_HSU m_hsu;

		public LG_HSU_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			m_hsu = ((Il2CppObjectBase)comp).Cast<LG_HSU>();
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = new Color(0.467f, 0.098f, 1f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_markerStyle = (eNavMarkerStyle)8;
			m_terminalItem = ((Il2CppObjectBase)m_hsu.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			if (((Interact_Base)m_hsu.m_pickupSampleInteraction).IsActive)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				OnManualUpdate();
			}
		}
	}
	public class LG_PowerGenerator_Marker : ItemMarkerBase
	{
		private LG_PowerGenerator_Core m_gene;

		public LG_PowerGenerator_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			m_gene = ((Il2CppObjectBase)comp).Cast<LG_PowerGenerator_Core>();
			m_gene.OnSyncStatusChanged += Action<ePowerGeneratorStatus>.op_Implicit((Action<ePowerGeneratorStatus>)OnSyncStateChange);
			m_marker = GuiManager.NavMarkerLayer.PrepareGenericMarker(comp.gameObject);
			m_markerColor = new Color(1f, 0.647f, 0f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_markerStyle = (eNavMarkerStyle)16;
			m_terminalItem = ((Il2CppObjectBase)m_gene.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
		}

		[HideFromIl2Cpp]
		private void OnSyncStateChange(ePowerGeneratorStatus status)
		{
			if (!base.IsDiscovered)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else if (((Behaviour)((Il2CppObjectBase)m_gene.m_powerCellInteraction).Cast<LG_GenericCarryItemInteractionTarget>()).isActiveAndEnabled)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			if (!m_gene.m_graphics.m_gfxSlot.active)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else if (((Behaviour)((Il2CppObjectBase)m_gene.m_powerCellInteraction).Cast<LG_GenericCarryItemInteractionTarget>()).isActiveAndEnabled)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			if (m_markerForceVisibleTimer >= Clock.Time)
			{
				AttemptInteract((eNavMarkerInteractionType)0);
			}
			else
			{
				OnManualUpdate();
			}
		}
	}
	public class LG_SecurityDoor_Locks_Marker : ItemMarkerBase
	{
		private LG_SecurityDoor_Locks m_locks;

		private LG_SecurityDoor m_door;

		public LG_SecurityDoor_Locks_Marker(IntPtr ptr)
			: base(ptr)
		{
		}

		[HideFromIl2Cpp]
		public override void SetupNavMarker(Component comp)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			m_locks = ((Il2CppObjectBase)comp).Cast<LG_SecurityDoor_Locks>();
			m_door = m_locks.m_door;
			m_marker = GuiManager.NavMarkerLayer.PlaceCustomMarker((NavMarkerOption)18, ((Component)m_locks.m_intOpenDoor).gameObject, string.Empty, 0f, false);
			m_markerColor = new Color(0.467f, 0.098f, 1f);
			m_markerVisibleUpdateMode = ItemMarkerVisibleUpdateModeType.Manual;
			m_terminalItem = ((Il2CppObjectBase)m_door.m_terminalItem).Cast<LG_GenericTerminalItem>();
			m_markerTitle = m_terminalItem.TerminalItemKey;
			m_markerStyle = (eNavMarkerStyle)0;
			m_markerIconScale = 0.275f;
			m_locks.OnApproached += Action.op_Implicit((Action)OnApproached);
			m_door.m_sync.OnDoorStateChange += Action<pDoorState, bool>.op_Implicit((Action<pDoorState, bool>)OnDoorStateChange);
			m_overridePlayerPing = false;
			m_markerShowPin = true;
			base.SetupNavMarker(comp);
			m_marker.SetVisualStates((NavMarkerOption)18, (NavMarkerOption)18, (NavMarkerOption)0, (NavMarkerOption)0);
			m_stateOptions = Il2CppArrayBase<NavMarkerOption>.op_Implicit((Il2CppArrayBase<NavMarkerOption>)(object)m_marker.m_stateOptions);
			((Component)m_marker.m_titleSubObj).transform.localScale = Vector3.one * 1.75f;
			((TMP_Text)m_marker.m_title).fontSizeMax = 50f;
			((TMP_Text)m_marker.m_title).fontSizeMin = 15f;
		}

		[HideFromIl2Cpp]
		private void OnApproached()
		{
			base.IsDiscovered = true;
		}

		[HideFromIl2Cpp]
		private void OnDoorStateChange(pDoorState state, bool isRecall)
		{
			if (!base.IsDiscovered)
			{
				AttemptInteract((eNavMarkerInteractionType)1);
			}
			else
			{
				OnManualUpdate();
			}
		}

		[HideFromIl2Cpp]
		protected override void OnManualUpdate()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			eDoorStatus status = m_door.m_sync.GetCurrentSyncState().status;
			if ((int)status <= 6)
			{
				if ((int)status != 1)
				{
					if ((int)status == 3)
					{
						m_markerColor = ColorExt.Hex("#FF9DE7");
						m_marker.SetColor(m_markerColor);
						m_markerTitle = "<color=orange>::REQ::</color>\n<color=white>" + m_locks.m_gateKeyItemNeeded.PublicName + "</color>";
						m_marker.SetTitle(m_markerTitle);
						AttemptInteract((eNavMarkerInteractionType)0);
						return;
					}
					if ((int)status == 6)
					{
						m_markerColor = ColorExt.Hex("#FFA500");
						m_marker.SetColor(m_markerColor);
						m_markerTitle = "<color=orange>::REQ::</color>\n<color=white>" + m_locks.m_powerGeneratorNeeded.PublicName + "</color>";
						m_marker.SetTitle(m_markerTitle);
						AttemptInteract((eNavMarkerInteractionType)0);
						return;
					}
				}
			}
			else if (status - 9 > 1)
			{
				if ((int)status == 15)
				{
					m_markerColor = ColorExt.Hex("#92A9B7");
					m_marker.SetColor(m_markerColor);
					m_markerTitle = "<color=orange>::REQ::</color>\n<color=white>" + m_locks.LinkedBulkheadDoorController.PublicName + "</color>";
					m_marker.SetTitle(m_markerTitle);
					AttemptInteract((eNavMarkerInteractionType)0);
					return;
				}
				if ((int)status == 16)
				{
				}
			}
			AttemptInteract((eNavMarkerInteractionType)1);
		}

		[HideFromIl2Cpp]
		protected override void OnDevUpdate()
		{
			OnManualUpdate();
		}
	}
}
namespace Hikaria.ItemMarker.Features
{
	[EnableFeatureByDefault]
	[DisallowInGameToggle]
	[HideInModSettings]
	[DoNotSaveToConfig]
	public class ItemMarker : Feature
	{
		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class PlayerAgent__set_CourseNode__Patch
		{
			private static bool nodeChanged;

			private static bool zoneChanged;

			private static bool dimensionChanged;

			private static AIG_CourseNode preNode;

			private static void Prefix(PlayerAgent __instance, AIG_CourseNode value)
			{
				//IL_00fc: 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)
				//IL_012a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: Unknown result type (might be due to invalid IL or missing references)
				if (((Agent)__instance).IsLocallyOwned)
				{
					preNode = ((Agent)__instance).CourseNode;
					AIG_CourseNode obj = preNode;
					nodeChanged = ((obj != null) ? new int?(obj.NodeID) : null) != ((value != null) ? new int?(value.NodeID) : null);
					AIG_CourseNode obj2 = preNode;
					zoneChanged = ((obj2 != null) ? new int?(obj2.m_zone.ID) : null) != ((value != null) ? new int?(value.m_zone.ID) : null);
					AIG_CourseNode obj3 = preNode;
					dimensionChanged = ((obj3 != null) ? new eDimensionIndex?(obj3.m_dimension.DimensionIndex) : null) != ((value != null) ? new eDimensionIndex?(value.m_dimension.DimensionIndex) : null);
				}
			}

			private static void Postfix(AIG_CourseNode value)
			{
				if (nodeChanged)
				{
					nodeChanged = false;
					ItemMarkerManager.OnPlayerCourseNodeChanged(value);
				}
				if (zoneChanged)
				{
					zoneChanged = false;
					ItemMarkerManager.OnPlayerZoneChanged((value != null) ? value.m_zone : null);
				}
				if (dimensionChanged)
				{
					dimensionChanged = false;
					ItemMarkerManager.OnPlayerDimensionChanged((value != null) ? value.m_dimension : null);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class PlayerAgent__Setup__Patch
		{
			private static void Postfix(PlayerAgent __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<ItemScanner>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<ItemScanner>();
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_ResourceContainer_Sync__OnStateChange__Patch
		{
			private static void Postfix(LG_ResourceContainer_Sync __instance, pResourceContainerItemState newState)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Invalid comparison between Unknown and I4
				if ((int)newState.status != 3)
				{
					return;
				}
				foreach (ItemMarkerTag componentsInChild in ((Component)__instance).GetComponentsInChildren<ItemMarkerTag>(true))
				{
					componentsInChild.ItemMarker.IsDiscovered = true;
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class SyncedNavMarkerWrapper__OnStateChange__Patch
		{
			private static bool Prefix(SyncedNavMarkerWrapper __instance, ref pNavMarkerState newState)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Invalid comparison between Unknown and I4
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Invalid comparison between Unknown and I4
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Invalid comparison between Unknown and I4
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014c: Invalid comparison between Unknown and I4
				//IL_006c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: 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_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.m_playerIndex == -1)
				{
					return true;
				}
				ItemMarkerTag itemMarkerTag = null;
				bool flag = false;
				if ((int)newState.status == 0 && (int)newState.style != 10 && (int)newState.style != 11)
				{
					foreach (Collider item in (Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(newState.worldPos, 0.001f, LayerManager.MASK_PING_TARGET))
					{
						itemMarkerTag = ((Component)item).GetComponent<ItemMarkerTag>();
						if (!((Object)(object)itemMarkerTag == (Object)null) && itemMarkerTag.ItemMarker.Style == newState.style)
						{
							if (itemMarkerTag.ItemMarker.OnPlayerPing())
							{
								newState.worldPos = itemMarkerTag.ItemMarker.WorldPos;
								newState.status = (eNavMarkerStatus)0;
								flag = true;
							}
							break;
						}
					}
				}
				if (flag)
				{
					__instance.m_markerHideTimer = Clock.Time + itemMarkerTag.ItemMarker.PlayerPingFadeOutTime;
					((Component)__instance).transform.position = newState.worldPos;
					__instance.m_marker.SetStyle(newState.style);
					__instance.m_marker.SetVisible(false);
					__instance.LastVisibleTerminalItemId = newState.terminalItemId;
					__instance.m_sound.UpdatePosition(newState.worldPos);
					if ((int)newState.style != 15 && PlayerManager.HasLocalPlayerAgent() && PlayerManager.GetLocalPlayerSlotIndex() != __instance.m_playerIndex)
					{
						if ((int)newState.style == 0 || (int)newState.style == 1)
						{
							__instance.m_sound.Post(EVENTS.PING_RECEIVED_GENERIC, true);
						}
						else
						{
							__instance.m_sound.Post(EVENTS.PING_RECEIVED_SPECIFIC, true);
						}
					}
					__instance.OnSyncedStateChange?.Invoke(__instance.m_playerIndex, newState);
					return false;
				}
				return true;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_GenericTerminalItem__PlayPing__Patch
		{
			private static void Postfix(LG_GenericTerminalItem __instance)
			{
				ItemMarkerManager.OnTerminalPing(((Object)__instance).GetInstanceID());
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class ItemSpawnManager__SpawnItem__Patch
		{
			private static void Postfix(Item __result)
			{
				//IL_004d: 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_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				ItemInLevel val = ((__result != null) ? ((Il2CppObjectBase)__result).TryCast<ItemInLevel>() : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((Object)(object)((Component)val).GetComponent<ItemInLevel_Marker>() == (Object)null)
				{
					((Component)val).gameObject.AddComponent<ItemInLevel_Marker>().SetupNavMarker((Component)(object)val);
				}
				if (val.CourseNode != null || val.internalSync == null || (int)val.internalSync.GetCurrentState().status != 0)
				{
					return;
				}
				pItemData pItemData = ((Item)val).Get_pItemData();
				AIG_CourseNode courseNode = default(AIG_CourseNode);
				if (((pCourseNode)(ref pItemData.originCourseNode)).TryGet(ref courseNode))
				{
					val.CourseNode = courseNode;
					return;
				}
				iTerminalItem component = ((Component)val).GetComponent<iTerminalItem>();
				if (component != null)
				{
					if (component.SpawnNode == null)
					{
						LG_Area componentInParent = ((Component)((Il2CppObjectBase)component).Cast<LG_GenericTerminalItem>()).GetComponentInParent<LG_Area>();
						if ((Object)(object)componentInParent != (Object)null)
						{
							component.SpawnNode = componentInParent.m_courseNode;
						}
					}
					if (val.CourseNode == null && component.SpawnNode != null)
					{
						val.CourseNode = component.SpawnNode;
						return;
					}
				}
				Transform parent = ((Component)val).transform.parent;
				object obj;
				if (parent == null)
				{
					obj = null;
				}
				else
				{
					Transform parent2 = parent.parent;
					obj = ((parent2 != null) ? ((Component)parent2).GetComponentInChildren<LG_PickupItem>() : null);
				}
				LG_PickupItem val2 = (LG_PickupItem)obj;
				if ((Object)(object)val2 != (Object)null)
				{
					val.CourseNode = val2.SpawnNode;
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_ResourceContainer_Storage__SetSpawnNode__Patch
		{
			private static void Postfix(LG_ResourceContainer_Storage __instance, GameObject obj, AIG_CourseNode spawnNode)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				foreach (ItemInLevel componentsInChild in obj.GetComponentsInChildren<ItemInLevel>())
				{
					if (componentsInChild.CourseNode == null && (int)componentsInChild.internalSync.GetCurrentState().status == 0)
					{
						componentsInChild.CourseNode = spawnNode;
					}
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class CarryItemPickup_Core__OnCustomDataUpdated__Patch
		{
			private static void Postfix(CarryItemPickup_Core __instance, pItemData_Custom customDataCopy)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (ItemInLevel_Marker.ItemInLevelMarkerLookup.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
				{
					value.OnItemCustomDataUpdate(customDataCopy);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class ResourcePackPickup__OnCustomDataUpdated__Patch
		{
			private static void Postfix(ResourcePackPickup __instance, pItemData_Custom customDataCopy)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (ItemInLevel_Marker.ItemInLevelMarkerLookup.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
				{
					value.OnItemCustomDataUpdate(customDataCopy);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class ConsumablePickup_Core__OnCustomDataUpdated__Patch
		{
			private static void Postfix(ConsumablePickup_Core __instance, pItemData_Custom customDataCopy)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if (ItemInLevel_Marker.ItemInLevelMarkerLookup.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
				{
					value.OnItemCustomDataUpdate(customDataCopy);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_ComputerTerminal__Setup__Patch
		{
			private static void Postfix(LG_ComputerTerminal __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_ComputerTerminal_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_ComputerTerminal_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_GenericTerminalItem__Setup__Patch
		{
			private static void Postfix(LG_GenericTerminalItem __instance, string key)
			{
				ItemMarkerManager.OnTerminalItemKeyUpdate(((Object)__instance).GetInstanceID(), key);
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_WardenObjective_Reactor__OnBuildDone__Patch
		{
			private static void Postfix(LG_WardenObjective_Reactor __instance)
			{
				if (__instance.SpawnNode != null && (Object)(object)__instance.m_terminal != (Object)null && !__instance.SpawnNode.m_zone.TerminalsSpawnedInZone.Contains(__instance.m_terminal))
				{
					__instance.SpawnNode.m_zone.TerminalsSpawnedInZone.Add(__instance.m_terminal);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_BulkheadDoorController_Core__Setup__Patch
		{
			private static void Postfix(LG_BulkheadDoorController_Core __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_BulkheadDoorController_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_BulkheadDoorController_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_PowerGenerator_Core__Setup__Patch
		{
			private static void Postfix(LG_PowerGenerator_Core __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_PowerGenerator_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_PowerGenerator_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_HSU__Setup__Patch
		{
			private static void Postfix(LG_HSU __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_HSU_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_HSU_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_HSUActivator_Core__SetupAsWardenObjective__Patch
		{
			private static void Postfix(LG_HSUActivator_Core __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_HSUActivator_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_HSUActivator_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_HSUActivator_Core__SetupFromCustomGeomorph__Patch
		{
			private static void Postfix(LG_HSUActivator_Core __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_HSUActivator_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_HSUActivator_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_SecurityDoor_Locks__SetupForBulkheadDC__Patch
		{
			private static void Postfix(LG_SecurityDoor_Locks __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_SecurityDoor_Locks_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_SecurityDoor_Locks_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_SecurityDoor_Locks__SetupForGateKey__Patch
		{
			private static void Postfix(LG_SecurityDoor_Locks __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_SecurityDoor_Locks_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_SecurityDoor_Locks_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_SecurityDoor_Locks__SetupForPowerGenerator__Patch
		{
			private static void Postfix(LG_SecurityDoor_Locks __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_SecurityDoor_Locks_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_SecurityDoor_Locks_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class LG_DisinfectionStation__Setup__Patch
		{
			private static void Postfix(LG_DisinfectionStation __instance)
			{
				if ((Object)(object)((Component)__instance).GetComponent<LG_DisinfectionStation_Marker>() == (Object)null)
				{
					((Component)__instance).gameObject.AddComponent<LG_DisinfectionStation_Marker>().SetupNavMarker((Component)(object)__instance);
				}
			}
		}

		public override string Name => "物品标记";

		public static ILocalizationService Localization { get; set; }

		public override void Init()
		{
			IconManager.Init();
			ItemMarkerManager.Init();
		}

		public override void OnGameStateChanged(int state)
		{
			if (state == 10)
			{
				ItemMarkerManager.SearchGameObject();
			}
		}

		public override void OnGameDataInitialized()
		{
			ItemInLevel_Marker.OnGameDataInitialized();
		}
	}
}