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 System.Text.Json;
using System.Text.Json.Serialization;
using AIGraph;
using AK;
using Agents;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using GameData;
using Gear;
using HarmonyLib;
using Hikaria.ItemMarker;
using Hikaria.ItemMarker.Features;
using Hikaria.ItemMarker.Framework;
using Hikaria.ItemMarker.Handlers;
using Hikaria.ItemMarker.Handlers.Markers;
using Hikaria.ItemMarker.Managers;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections;
using LevelGeneration;
using Player;
using SNetwork;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ItemMarkerProMax")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.1.0.0")]
[assembly: AssemblyInformationalVersion("1.1.0")]
[assembly: AssemblyProduct("ItemMarkerProMax")]
[assembly: AssemblyTitle("ItemMarkerProMax")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.0.0")]
[module: UnverifiableCode]
namespace ItemMarkerProMax
{
	[BepInPlugin("QingJu.ItemMarkerProMax", "ItemMarkerProMax", "1.1.0")]
	public sealed class Plugin : BasePlugin
	{
		internal static readonly ItemMarker MarkerFeature = new ItemMarker();

		public override void Load()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Logs.Setup(((BasePlugin)this).Log);
			EntryPoint.Init();
			ClassInjector.RegisterTypeInIl2Cpp<ItemMarkerHost>();
			ItemMarkerHost.Instance = ((BasePlugin)this).AddComponent<ItemMarkerHost>();
			new Harmony("QingJu.ItemMarkerProMax").PatchAll(typeof(Plugin).Assembly);
			MarkerFeature.Init();
			FeatureDriver.Attach(MarkerFeature);
			Logs.LogInfo("ItemMarkerProMax 1.1.0 loaded");
		}
	}
	public static class PluginInfo
	{
		public const string GUID = "QingJu.ItemMarkerProMax";

		public const string NAME = "ItemMarkerProMax";

		public const string VERSION = "1.1.0";
	}
}
namespace Hikaria.ItemMarker
{
	public static class EntryPoint
	{
		public static void Init()
		{
			LocalizationService localizationService = (LocalizationService)(Hikaria.ItemMarker.Features.ItemMarker.Localization = new LocalizationService());
			Logs.LogInfo($"Localization: {localizationService.EntryCount} generic texts read from the archived JSON");
		}
	}
	internal static class Logs
	{
		private static ManualLogSource _logger;

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

		public static void LogDebug(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogDebug((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogInfo(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogWarning(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogWarning((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogError(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogError((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogMessage(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogNotice(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogSuccess(object data)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogInfo((object)(data?.ToString() ?? string.Empty));
			}
		}

		public static void LogException(Exception ex)
		{
			ManualLogSource logger = _logger;
			if (logger != null)
			{
				logger.LogError((object)ex);
			}
		}
	}
}
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
	{
		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();
				}
			}
		}

		private static IEnumerator UpdateDevMode(ItemMarkerBase marker)
		{
			WaitForSecondsRealtime yielder = new WaitForSecondsRealtime(0.2f);
			while (DevMode)
			{
				try
				{
					marker.DoDevModeUpdate();
				}
				catch
				{
				}
				yield return yielder;
			}
		}

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

		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>();
			_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;
		}

		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()
		{
		}

		[HideFromIl2Cpp]
		protected IEnumerator HideDelay(float delay)
		{
			yield return (object)new WaitForSecondsRealtime(delay);
			ForceUpdate();
		}

		[HideFromIl2Cpp]
		private IEnumerator UpdateMarkerAlphaCoroutine()
		{
			WaitForFixedUpdate yielder = new WaitForFixedUpdate();
			while ((Object)(object)m_marker != (Object)null)
			{
				UpdateMarkerAlpha();
				yield return yielder;
			}
		}

		[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; } = Color.white.ToSColor();

			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>());

		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_03a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_03af: Unknown result type (might be due to invalid IL or missing references)
				//IL_03b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03cf: 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_03df: Unknown result type (might be due to invalid IL or missing references)
				//IL_03e4: 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(1)}</color>\n{(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</color>\n"))}{m_markerTitle}";
						}
						return (base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</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)
						{
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler;
							if (m_itemShowUses)
							{
								defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(22, 4);
								defaultInterpolatedStringHandler.AppendLiteral("<color=red>");
								defaultInterpolatedStringHandler.AppendFormatted(Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(3));
								defaultInterpolatedStringHandler.AppendLiteral("</color>\n");
								defaultInterpolatedStringHandler.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</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 = new DefaultInterpolatedStringHandler(20, 3);
							defaultInterpolatedStringHandler.AppendLiteral("<color=red>");
							defaultInterpolatedStringHandler.AppendFormatted(Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(3));
							defaultInterpolatedStringHandler.AppendLiteral("</color>\n");
							defaultInterpolatedStringHandler.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</color>\n"));
							LG_GenericTerminalItem terminalItem3 = m_terminalItem;
							defaultInterpolatedStringHandler.AppendFormatted(((terminalItem3 != null) ? terminalItem3.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
							return defaultInterpolatedStringHandler.ToStringAndClear();
						}
						if (m_itemShowUses)
						{
							DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(2, 3);
							defaultInterpolatedStringHandler.AppendFormatted(base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</color>\n"));
							LG_GenericTerminalItem terminalItem4 = m_terminalItem;
							defaultInterpolatedStringHandler.AppendFormatted(((terminalItem4 != null) ? terminalItem4.TerminalItemKey : null) ?? ((Item)m_item).PublicName);
							defaultInterpolatedStringHandler.AppendLiteral(" ×");
							defaultInterpolatedStringHandler.AppendFormatted(m_itemUsesLeft);
							return defaultInterpolatedStringHandler.ToStringAndClear();
						}
						string obj = (base.IsDiscovered ? string.Empty : ("<color=red>" + Hikaria.ItemMarker.Features.ItemMarker.Localization.GetById(2) + "</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(1) + "</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_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Invalid comparison between Unknown and I4
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			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);
			iPlayerPingTarget componentInChildren = ((Component)this).GetComponentInChildren<iPlayerPingTarget>();
			m_markerStyle = (eNavMarkerStyle)((componentInChildren != null) ? ((int)componentInChildren.PingTargetStyle) : 0);
			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 = value.Color.ToUnityColor();
				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.Framework
{
	public static class CoroutineManager
	{
		public static Coroutine StartCoroutine(IEnumerator routine)
		{
			return ((MonoBehaviour)ItemMarkerHost.Instance).StartCoroutine(routine);
		}

		public static void StopCoroutine(Coroutine routine)
		{
			if (routine != null)
			{
				((MonoBehaviour)ItemMarkerHost.Instance).StopCoroutine(routine);
			}
		}
	}
	internal sealed class CustomSetting<T>
	{
		public T Value { get; }

		public CustomSetting(string name, T fallback)
		{
			string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, "Settings", name + ".json");
			try
			{
				JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions
				{
					IncludeFields = true,
					PropertyNameCaseInsensitive = true
				};
				jsonSerializerOptions.Converters.Add(new JsonStringEnumConverter());
				Value = (T)(File.Exists(path) ? ((object)JsonSerializer.Deserialize<T>(File.ReadAllText(path), jsonSerializerOptions)) : ((object)fallback));
				T value = Value;
				if (value == null)
				{
					Value = fallback;
				}
			}
			catch (Exception ex)
			{
				Logs.LogWarning("Invalid settings file " + name + ".json; using defaults: " + ex.Message);
				Value = fallback;
			}
		}
	}
	public struct SColor
	{
		public float R { get; set; }

		public float G { get; set; }

		public float B { get; set; }

		public float A { get; set; }

		public Color ToUnityColor()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Color(R, G, B, A);
		}
	}
	public static class SColorExtensions
	{
		public static SColor ToSColor(this Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			return new SColor
			{
				R = color.r,
				G = color.g,
				B = color.b,
				A = color.a
			};
		}
	}
	public abstract class Feature
	{
		public abstract string Name { get; }

		public static ILocalizationService Localization { get; set; }

		public virtual void Init()
		{
		}

		public virtual void OnGameStateChanged(int state)
		{
		}

		public virtual void OnGameDataInitialized()
		{
		}
	}
	internal static class FeatureDriver
	{
		private static Feature _feature;

		private static bool _gameDataInitialized;

		internal static void Attach(Feature feature)
		{
			_feature = feature;
			GameEventAPI.OnGameStateChanged += OnGameStateChanged;
		}

		private static void OnGameStateChanged(eGameStateName previous, eGameStateName next)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected I4, but got Unknown
			if (_feature == null)
			{
				return;
			}
			if ((int)next == 10 && !_gameDataInitialized)
			{
				_gameDataInitialized = true;
				try
				{
					_feature.OnGameDataInitialized();
				}
				catch (Exception ex)
				{
					Logs.LogException(ex);
				}
			}
			try
			{
				_feature.OnGameStateChanged((int)next);
			}
			catch (Exception ex2)
			{
				Logs.LogException(ex2);
			}
		}
	}
	public static class GameEventAPI
	{
		public static event Action<eGameStateName, eGameStateName> OnGameStateChanged;

		internal static void RaiseGameStateChanged(eGameStateName previous, eGameStateName next)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			Action<eGameStateName, eGameStateName> onGameStateChanged = GameEventAPI.OnGameStateChanged;
			if (onGameStateChanged == null)
			{
				return;
			}
			Delegate[] invocationList = onGameStateChanged.GetInvocationList();
			foreach (Delegate obj in invocationList)
			{
				try
				{
					((Action<eGameStateName, eGameStateName>)obj)(previous, next);
				}
				catch (Exception ex)
				{
					Logs.LogException(ex);
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameStateManager), "DoChangeState")]
	internal static class GameStateManagerChangePatch
	{
		private static void Prefix(out eGameStateName __state)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected I4, but got Unknown
			__state = (eGameStateName)(int)GameStateManager.CurrentStateName;
		}

		private static void Postfix(eGameStateName nextState, eGameStateName __state)
		{
			//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)
			GameEventAPI.RaiseGameStateChanged(__state, nextState);
		}
	}
	public interface ILocalizationService
	{
		string GetById(int id);
	}
	public class ItemMarkerHost : MonoBehaviour
	{
		internal static ItemMarkerHost Instance { get; set; }

		public ItemMarkerHost(IntPtr ptr)
			: base(ptr)
		{
		}
	}
	public sealed class LocalizationService : ILocalizationService
	{
		private const string ResourceMarker = "Localization.";

		private const string FallbackLanguage = "Chinese";

		private readonly Dictionary<int, Dictionary<string, string>> _genericTexts = new Dictionary<int, Dictionary<string, string>>();

		public string Language { get; set; } = "Chinese";

		public int EntryCount => _genericTexts.Count;

		public LocalizationService()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
			foreach (string text in manifestResourceNames)
			{
				if (!text.Contains("Localization.", StringComparison.Ordinal))
				{
					continue;
				}
				using Stream stream = executingAssembly.GetManifestResourceStream(text);
				if (stream != null)
				{
					Load(stream);
				}
			}
		}

		public string GetById(int id)
		{
			if (!_genericTexts.TryGetValue(id, out var value))
			{
				return string.Empty;
			}
			return Pick(value, Language) ?? Pick(value, "Chinese") ?? Pick(value, "English") ?? Pick(value, "Comment") ?? string.Empty;
		}

		private static string Pick(Dictionary<string, string> texts, string key)
		{
			if (key == null || !texts.TryGetValue(key, out var value) || string.IsNullOrEmpty(value))
			{
				return null;
			}
			return value;
		}

		private void Load(Stream stream)
		{
			using JsonDocument jsonDocument = JsonDocument.Parse(stream);
			if (!jsonDocument.RootElement.TryGetProperty("GenericTexts", out var value) || value.ValueKind != JsonValueKind.Object)
			{
				return;
			}
			foreach (JsonProperty item in value.EnumerateObject())
			{
				if (!int.TryParse(item.Name, out var result) || item.Value.ValueKind != JsonValueKind.Object)
				{
					continue;
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
				if (item.Value.TryGetProperty("Data", out var value2) && value2.ValueKind == JsonValueKind.Object)
				{
					foreach (JsonProperty item2 in value2.EnumerateObject())
					{
						if (item2.Value.ValueKind == JsonValueKind.String)
						{
							dictionary[item2.Name] = item2.Value.GetString();
						}
					}
				}
				if (item.Value.TryGetProperty("Comment", out var value3) && value3.ValueKind == JsonValueKind.String)
				{
					dictionary["Comment"] = value3.GetString();
				}
				_genericTexts[result] = dictionary;
			}
		}
	}
	public static class SNetEventAPI
	{
		public static event Action OnResetSession;

		public static event Action<eBufferType> OnRecallComplete;

		public static event Action<pBufferCommand> OnBufferCommand;

		internal static void RaiseResetSession()
		{
			Invoke(SNetEventAPI.OnResetSession);
		}

		internal static void RaiseRecallComplete(eBufferType bufferType)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Invoke(SNetEventAPI.OnRecallComplete, bufferType);
		}

		internal static void RaiseBufferCommand(pBufferCommand command)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			Invoke(SNetEventAPI.OnBufferCommand, command);
		}

		private static void Invoke(Delegate callbacks, params object[] args)
		{
			if ((object)callbacks == null)
			{
				return;
			}
			Delegate[] invocationList = callbacks.GetInvocationList();
			foreach (Delegate obj in invocationList)
			{
				try
				{
					obj.DynamicInvoke(args);
				}
				catch (Exception ex)
				{
					Logs.LogException(ex);
				}
			}
		}
	}
	[HarmonyPatch(typeof(SNet_SyncManager), "OnResetSession")]
	internal static class SNetSyncManagerResetPatch
	{
		private static void Postfix()
		{
			SNetEventAPI.RaiseResetSession();
		}
	}
	[HarmonyPatch(typeof(SNet_SyncManager), "OnRecallDone")]
	internal static class SNetSyncManagerRecallPatch
	{
		private static void Postfix(eBufferType bufferType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			SNetEventAPI.RaiseRecallComplete(bufferType);
		}
	}
	[HarmonyPatch(typeof(SNet_Capture), "OnBufferCommand")]
	internal static class SNetCaptureBufferCommandPatch
	{
		private static void Prefix(pBufferCommand command)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			SNetEventAPI.RaiseBufferCommand(command);
		}
	}
}
namespace Hikaria.ItemMarker.Features
{
	public class ItemMarker : Feature
	{
		[HarmonyPatch(typeof(PlayerAgent), "set_CourseNode")]
		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) : ((int?)null)) != ((value != null) ? new int?(value.NodeID) : ((int?)null));
					AIG_CourseNode obj2 = preNode;
					zoneChanged = ((obj2 != null) ? new int?(obj2.m_zone.ID) : ((int?)null)) != ((value != null) ? new int?(value.m_zone.ID) : ((int?)null));
					AIG_CourseNode obj3 = preNode;
					dimensionChanged = ((obj3 != null) ? new eDimensionIndex?(obj3.m_dimension.DimensionIndex) : ((eDimensionIndex?)null)) != ((value != null) ? new eDimensionIndex?(value.m_dimension.DimensionIndex) : ((eDimensionIndex?)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);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerAgent), "Setup")]
		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>();
				}
			}
		}

		[HarmonyPatch(typeof(LG_ResourceContainer_Sync), "OnStateChange")]
		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;
				}
			}
		}

		[HarmonyPatch(typeof(SyncedNavMarkerWrapper), "OnStateChange")]
		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;
			}
		}

		[HarmonyPatch(typeof(LG_GenericTerminalItem), "PlayPing")]
		private class LG_GenericTerminalItem__PlayPing__Patch
		{
			private static void Postfix(LG_GenericTerminalItem __instance)
			{
				ItemMarkerManager.OnTerminalPing(((Object)__instance).GetInstanceID());
			}
		}

		[HarmonyPatch(typeof(ItemSpawnManager), "SpawnItem")]
		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;
				}
			}
		}

		[HarmonyPatch(typeof(LG_ResourceContainer_Storage), "SetSpawnNode")]
		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;
					}
				}
			}
		}

		[HarmonyPatch(typeof(CarryItemPickup_Core), "OnCustomDataUpdated")]
		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);
				}
			}
		}

		[HarmonyPatch(typeof(ResourcePackPickup), "OnCustomDataUpdated")]
		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);
				}
			}
		}

		[HarmonyPatch(typeof(ConsumablePickup_Core), "OnCustomDataUpdated")]
		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);
				}
			}
		}

		[HarmonyPatch(typeof(LG_ComputerTerminal), "Setup")]
		private class LG_ComputerTerminal__Setup__Patch
		{
			private static void Postfix