using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AK;
using Agents;
using Enemies;
using GameData;
using Gear;
using Hikaria.Core;
using Hikaria.Core.SNetworkExt;
using Hikaria.MapperTracker.Controllers;
using Hikaria.MapperTracker.Features;
using Hikaria.MapperTracker.Managers;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using Player;
using SNetwork;
using TMPro;
using TheArchive.Core;
using TheArchive.Core.Attributes;
using TheArchive.Core.Attributes.Feature;
using TheArchive.Core.Attributes.Feature.Members;
using TheArchive.Core.Attributes.Feature.Patches;
using TheArchive.Core.Attributes.Feature.Settings;
using TheArchive.Core.FeaturesAPI;
using TheArchive.Core.Localization;
using TheArchive.Core.Models;
using TheArchive.Interfaces;
using TheArchive.Loader;
using TheArchive.Utilities;
using UnityEngine;
using UnityEngine.Rendering;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Hikaria.MapperTracker
{
	[ArchiveDependency(/*Could not decode attribute arguments.*/)]
	[ArchiveModule("Hikaria.LidarBiotracker", "LiDaR Biotracker", "1.0.0")]
	public class EntryPoint : IArchiveModule
	{
		public ILocalizationService LocalizationService { get; set; }

		public IArchiveLogger Logger { get; set; }

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

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

		public static void LogDebug(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Debug(data.ToString());
			}
		}

		public static void LogError(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Error(data.ToString());
			}
		}

		public static void LogInfo(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Info(data.ToString());
			}
		}

		public static void LogMessage(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Msg(ConsoleColor.White, data.ToString());
			}
		}

		public static void LogWarning(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Warning(data.ToString());
			}
		}

		public static void LogNotice(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Notice(data.ToString());
			}
		}

		public static void LogSuccess(object data)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Success(data.ToString());
			}
		}

		public static void LogException(Exception ex)
		{
			IArchiveLogger logger = _logger;
			if (logger != null)
			{
				logger.Exception(ex);
			}
		}
	}
	public struct pMapperTrackerXRayStatus
	{
		public bool enabled;

		public bool focus;

		public byte mode;

		public pPlayer player;

		public pMapperTrackerXRayStatus(SNet_Player owner)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			player = default(pPlayer);
			((pPlayer)(ref player)).SetPlayer(owner);
			enabled = false;
			focus = false;
			mode = 0;
		}
	}
	public struct pMapperTrackerXRayData
	{
		public pPlayer player;

		public float fieldOfView;

		public float fieldOfViewFocused;

		public float maxDistanceDefault;

		public float maxDistanceFocused;

		public int raysPerSecondDefault;

		public int raysPerSecondFocused;

		public pMapperTrackerXRayData(SNet_Player owner)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			player = default(pPlayer);
			((pPlayer)(ref player)).SetPlayer(owner);
			fieldOfView = 84f;
			fieldOfViewFocused = 28f;
			maxDistanceDefault = 18f;
			maxDistanceFocused = 32f;
			raysPerSecondDefault = 28000;
			raysPerSecondFocused = 18000;
		}
	}
	public static class PluginInfo
	{
		public const string GUID = "Hikaria.LidarBiotracker";

		public const string NAME = "LiDaR Biotracker";

		public const string VERSION = "1.0.0";
	}
	public enum ToolMode : byte
	{
		EnemyPulse
	}
}
namespace Hikaria.MapperTracker.Managers
{
	internal static class MapperTrackerManager
	{
		private static readonly VersionRange VersionRange = VersionRange.op_Implicit("1.x.x");

		public static SNetExt_BroadcastAction<pMapperTrackerXRayData> s_MapperTrackerXRayDataAction;

		public static SNetExt_BroadcastAction<pMapperTrackerXRayStatus> s_MapperTrackerXRayStatusAction;

		public static Dictionary<ulong, MapperTrackerController> MapperTrackerControllerLookup = new Dictionary<ulong, MapperTrackerController>();

		public static Dictionary<int, MapperTrackerController> MapperTrackerXRaysInstanceIDLookup = new Dictionary<int, MapperTrackerController>();

		public static Dictionary<int, MapperTrackerController> MapperTrackerGraphicsInstanceIDLookup = new Dictionary<int, MapperTrackerController>();

		public static void RegisterController(MapperTrackerController controller, EnemyScanner scanner, XRays xRays)
		{
			if (!((Object)(object)controller == (Object)null))
			{
				MapperTrackerControllerLookup[controller.OwnerLookupPublic] = controller;
				if ((Object)(object)xRays != (Object)null)
				{
					MapperTrackerXRaysInstanceIDLookup[((Object)xRays).GetInstanceID()] = controller;
				}
				if ((Object)(object)((scanner != null) ? scanner.m_graphics : null) != (Object)null)
				{
					MapperTrackerGraphicsInstanceIDLookup[((Object)scanner.m_graphics).GetInstanceID()] = controller;
				}
			}
		}

		public static void UnregisterController(MapperTrackerController controller, EnemyScanner scanner, XRays xRays)
		{
			if (!((Object)(object)controller == (Object)null))
			{
				MapperTrackerControllerLookup.Remove(controller.OwnerLookupPublic);
				if ((Object)(object)xRays != (Object)null)
				{
					MapperTrackerXRaysInstanceIDLookup.Remove(((Object)xRays).GetInstanceID());
				}
				if ((Object)(object)((scanner != null) ? scanner.m_graphics : null) != (Object)null)
				{
					MapperTrackerGraphicsInstanceIDLookup.Remove(((Object)scanner.m_graphics).GetInstanceID());
				}
			}
		}

		public static bool TryGetControllerForGraphics(EnemyScannerGraphics graphics, out MapperTrackerController controller)
		{
			controller = null;
			if ((Object)(object)graphics == (Object)null)
			{
				return false;
			}
			if (MapperTrackerGraphicsInstanceIDLookup.TryGetValue(((Object)graphics).GetInstanceID(), out controller) && (Object)(object)controller != (Object)null)
			{
				return true;
			}
			EnemyScanner val = FindScanner(((Component)graphics).transform);
			object obj;
			if (val == null)
			{
				obj = null;
			}
			else
			{
				PlayerAgent owner = ((Item)val).Owner;
				obj = ((owner != null) ? owner.Owner : null);
			}
			if ((Object)obj != (Object)null && MapperTrackerControllerLookup.TryGetValue(((Item)val).Owner.Owner.Lookup, out controller) && (Object)(object)controller != (Object)null)
			{
				MapperTrackerGraphicsInstanceIDLookup[((Object)graphics).GetInstanceID()] = controller;
				return true;
			}
			return false;
		}

		public static bool TryGetControllerForScanner(EnemyScanner scanner, out MapperTrackerController controller)
		{
			controller = null;
			object obj;
			if (scanner == null)
			{
				obj = null;
			}
			else
			{
				PlayerAgent owner = ((Item)scanner).Owner;
				obj = ((owner != null) ? owner.Owner : null);
			}
			if ((Object)obj == (Object)null)
			{
				return false;
			}
			if (MapperTrackerControllerLookup.TryGetValue(((Item)scanner).Owner.Owner.Lookup, out controller))
			{
				return (Object)(object)controller != (Object)null;
			}
			return false;
		}

		private static EnemyScanner FindScanner(Transform t)
		{
			while ((Object)(object)t != (Object)null)
			{
				EnemyScanner component = ((Component)t).GetComponent<EnemyScanner>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
				t = t.parent;
			}
			return null;
		}

		private static bool MapperTrackerListenerFilter(SNet_Player player)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return CoreAPI.IsPlayerInstalledMod(player, "Hikaria.LidarBiotracker", VersionRange);
		}

		public static void Setup()
		{
			s_MapperTrackerXRayDataAction = SNetExt_BroadcastAction<pMapperTrackerXRayData>.Create(typeof(pMapperTrackerXRayData).FullName, (Action<SNet_Player, pMapperTrackerXRayData>)ReceiveMapperXRayData, (Func<SNet_Player, bool>)MapperTrackerListenerFilter, (SNet_ChannelType)2);
			s_MapperTrackerXRayStatusAction = SNetExt_BroadcastAction<pMapperTrackerXRayStatus>.Create(typeof(pMapperTrackerXRayStatus).FullName, (Action<SNet_Player, pMapperTrackerXRayStatus>)ReceiveMapperXRayStatus, (Func<SNet_Player, bool>)MapperTrackerListenerFilter, (SNet_ChannelType)2);
		}

		private static void ReceiveMapperXRayStatus(SNet_Player sender, pMapperTrackerXRayStatus data)
		{
			SNet_Player val = default(SNet_Player);
			if (!((Object)(object)sender == (Object)null) && ((pPlayer)(ref data.player)).TryGetPlayer(ref val) && val.Lookup == sender.Lookup && MapperTrackerControllerLookup.TryGetValue(sender.Lookup, out var value))
			{
				value.SyncSetXRayStatus(data);
			}
		}

		private static void ReceiveMapperXRayData(SNet_Player sender, pMapperTrackerXRayData data)
		{
			SNet_Player val = default(SNet_Player);
			if (!((Object)(object)sender == (Object)null) && ((pPlayer)(ref data.player)).TryGetPlayer(ref val) && val.Lookup == sender.Lookup && MapperTrackerControllerLookup.TryGetValue(sender.Lookup, out var value))
			{
				value.SyncSetXRayData(data);
			}
		}
	}
}
namespace Hikaria.MapperTracker.Features
{
	[DisallowInGameToggle]
	[DoNotSaveToConfig]
	[EnableFeatureByDefault]
	public class MapperTracker : Feature
	{
		public class MapperTrackerSettings
		{
			[FSHeader("General", true)]
			[FSDisplayName("Enabled")]
			[FSDescription("Local toggle only. Does not affect other players.")]
			public bool EnableMapperTracker { get; set; } = true;

			[FSDisplayName("Biotracker Pulse Key")]
			[FSDescription("Toggle Biotracker mapper on/off. Hold RMB to zoom while on.")]
			public KeyCode ToggleKey { get; set; } = (KeyCode)120;

			[FSHeader("Scan", true)]
			[FSDisplayName("FOV (Normal)")]
			public float FieldOfView { get; set; } = 84f;

			[FSDisplayName("FOV (Focused)")]
			[FSDescription("Hold RMB while mapper is on to zoom.")]
			public float FieldOfViewFocused { get; set; } = 28f;

			[FSDisplayName("Max Distance (Normal)")]
			public float MaxDistanceDefault { get; set; } = 27f;

			[FSDisplayName("Max Distance (Focused)")]
			public float MaxDistanceFocused { get; set; } = 38f;

			[FSDisplayName("Rays / Sec (Normal)")]
			public int RaysPerSecondDefault { get; set; } = 6000;

			[FSDisplayName("Rays / Sec (Focused)")]
			public int RaysPerSecondFocused { get; set; } = 4000;

			[FSHeader("Enemy Highlights", true)]
			[FSDisplayName("Enemy Highlight Duration (s)")]
			public float EnemyHighlightSeconds { get; set; } = 1f;

			[FSDisplayName("Enemy Glow Phase Lag (s)")]
			public float EnemyGlowPhaseLagSeconds { get; set; } = 0.05f;

			[FSDisplayName("Enemy Pulse FOV")]
			public float EnemyPulseFov { get; set; } = 120f;

			[FSDisplayName("Pulse SFX")]
			public bool EnablePulseSfx { get; set; } = true;

			[FSHeader("Appearance", true)]
			[FSDisplayName("Cast Color")]
			[FSDescription("Fallback tint. Bio Cast uses HSV 0/0/0.2.")]
			public SColor DefaultColor { get; set; } = new SColor(0.2f, 0.2f, 0.2f, (float?)1f);

			[FSDisplayName("Cast Size")]
			public float DefaultSize { get; set; } = 1.05f;

			[FSDisplayName("Enemy Color")]
			public SColor EnemyColor { get; set; } = new SColor(1f, 0f, 0f, (float?)0.22f);

			[FSDisplayName("Weakspot / Head Color")]
			public SColor WeakspotColor { get; set; } = new SColor(1f, 0.82f, 0.1f, (float?)0.28f);

			[FSDisplayName("Enemy Size")]
			public float EnemySize { get; set; } = 2f;

			[FSDisplayName("Switch Color")]
			public SColor InteractionColor { get; set; } = new SColor(1f, 0.55f, 0.1f, (float?)0.85f);

			[FSDisplayName("Terminal Color")]
			public SColor TerminalColor { get; set; } = new SColor(0.15f, 0.85f, 1f, (float?)0.85f);

			[FSDisplayName("Locker Color")]
			public SColor LockerColor { get; set; } = new SColor(1f, 0.45f, 0.05f, (float?)0.85f);

			[FSDisplayName("Booster / Pickup Color")]
			public SColor BoosterColor { get; set; } = new SColor(0.35f, 1f, 0.25f, (float?)0.85f);

			[FSDisplayName("Interactable Size")]
			public float InteractionSize { get; set; } = 1f;

			[FSHeader("Teammate Highlights", true)]
			[FSDisplayName("Teammate Enemy")]
			public SColor TeammateEnemyColor { get; set; } = new SColor(1f, 0.25f, 0.55f, (float?)0.85f);

			[FSDisplayName("Teammate Weakspot / Head")]
			public SColor TeammateWeakspotColor { get; set; } = new SColor(1f, 0.9f, 0.35f, (float?)0.95f);

			[FSDisplayName("Teammate Switch")]
			public SColor TeammateSwitchColor { get; set; } = new SColor(1f, 0.75f, 0.2f, (float?)0.85f);

			[FSDisplayName("Teammate Terminal")]
			public SColor TeammateTerminalColor { get; set; } = new SColor(0.55f, 0.35f, 1f, (float?)0.85f);

			[FSDisplayName("Teammate Locker")]
			public SColor TeammateLockerColor { get; set; } = new SColor(1f, 0.3f, 0.15f, (float?)0.85f);

			[FSDisplayName("Teammate Booster / Pickup")]
			public SColor TeammateBoosterColor { get; set; } = new SColor(0.2f, 0.95f, 0.55f, (float?)0.85f);

			[FSHeader("Battery", true)]
			[FSDisplayName("Enable Battery")]
			public bool EnableBattery { get; set; } = true;

			[FSDisplayName("Battery Duration (s)")]
			public float BatteryDurationSeconds { get; set; } = 30f;

			[FSDisplayName("Recharge % / Sec")]
			public float BatteryRechargePercentPerSecond { get; set; } = 1f;

			[FSDisplayName("Glitch Duration (s)")]
			public float GlitchDurationSeconds { get; set; } = 2.5f;

			[FSDisplayName("Short-Circuit Sound")]
			public bool EnableShortCircuitSound { get; set; } = true;
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class EnemyScanner__UpdateTagProgress__Patch
		{
			private static bool Prefix(EnemyScanner __instance)
			{
				object obj;
				if (__instance == null)
				{
					obj = null;
				}
				else
				{
					PlayerAgent owner = ((Item)__instance).Owner;
					obj = ((owner != null) ? owner.Owner : null);
				}
				if ((Object)obj == (Object)null || !((Item)__instance).Owner.Owner.IsLocal)
				{
					return true;
				}
				if (!MapperTrackerManager.MapperTrackerControllerLookup.TryGetValue(((Item)__instance).Owner.Owner.Lookup, out var value) || (Object)(object)value == (Object)null)
				{
					return true;
				}
				if (value.IsShortCircuited)
				{
					return false;
				}
				return true;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class EnemyScanner__Update__Patch
		{
			private static void Postfix(EnemyScanner __instance)
			{
				object obj;
				if (__instance == null)
				{
					obj = null;
				}
				else
				{
					PlayerAgent owner = ((Item)__instance).Owner;
					obj = ((owner != null) ? owner.Owner : null);
				}
				if (!((Object)obj == (Object)null) && ((Item)__instance).Owner.Owner.IsLocal && MapperTrackerManager.TryGetControllerForScanner(__instance, out var controller) && !((Object)(object)controller == (Object)null))
				{
					controller.TickLocalInputFromScanner();
					BiotrackerFpVisual.SuppressFrontProjector(__instance);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class EnemyScanner__UpdateAndRenderScannerData__Patch
		{
			private static void Postfix(EnemyScanner __instance, EnemyAgent enemyAgent, EnemyScannerDataObject scannerData)
			{
				if ((Object)(object)__instance != (Object)null)
				{
					BatteryScreenUI.ApplyDotColorIfOffline(__instance, enemyAgent, scannerData);
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class XRayRenderer__Emit__Patch
		{
			private static bool Prefix(float size)
			{
				if (size <= 0.001f)
				{
					return false;
				}
				return true;
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class XRays__Update__Patch
		{
			private static bool Prefix(XRays __instance)
			{
				if (!MapperTrackerManager.MapperTrackerXRaysInstanceIDLookup.TryGetValue(((Object)__instance).GetInstanceID(), out var value))
				{
					return true;
				}
				try
				{
					if (!value.IsSyncEnabled || !value.IsPulseActive)
					{
						EntityXRayHighlight.Tick();
						if ((Object)(object)__instance.m_renderer != (Object)null)
						{
							__instance.m_renderer.range = __instance.maxDistance;
							__instance.m_renderer.mode = 0;
						}
						return false;
					}
					float num = Mathf.Min(0.05f, Time.deltaTime);
					int num2 = Mathf.CeilToInt((float)Mathf.Clamp(__instance.raysPerSecond, 500, 12000) * num);
					if (num2 > 180)
					{
						num2 = 180;
					}
					value.PrepareStockCastVisual();
					EntityXRayHighlight.AdvanceSwipePhase(__instance.swipeSpeed);
					__instance.Cast(num2);
					value.PaintSwipeCast(Mathf.Min(num2, 48));
					EntityXRayHighlight.PulseScan(__instance, value.IsSyncFocused, value.Owner, value.OwnerLookupPublic, value.IsLocallyOwned, scanEnemies: true, scanInteractables: false);
					EntityXRayHighlight.Tick();
					if ((Object)(object)__instance.m_renderer != (Object)null)
					{
						__instance.m_renderer.range = __instance.maxDistance;
						__instance.m_renderer.mode = 0;
					}
					return false;
				}
				catch
				{
					return false;
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class PlayerInventorySynced__SyncWieldItem__Patch
		{
			private static void Prefix(PlayerInventorySynced __instance, ItemEquippable item)
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)((__instance != null) ? ((PlayerInventoryBase)__instance).Owner : null) == (Object)null) && !((Object)(object)item == (Object)null) && CanDoMapper(item) && !((Object)(object)((Component)item).GetComponent<MapperTrackerController>() != (Object)null))
				{
					GameObject val = new GameObject("MapperTrackerController");
					val.transform.SetParent(((Component)item).transform, false);
					val.AddComponent<MapperTrackerController>().Setup(item, ((PlayerInventoryBase)__instance).Owner);
				}
			}

			private static void Postfix(PlayerInventorySynced __instance, ItemEquippable item)
			{
				if ((Object)(object)item == (Object)null)
				{
					return;
				}
				MapperTrackerController componentInChildren = ((Component)item).GetComponentInChildren<MapperTrackerController>(true);
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					if (item.m_isWielded)
					{
						componentInChildren.OnWield();
					}
					else
					{
						componentInChildren.OnUnWield();
					}
				}
			}
		}

		[ArchivePatch(/*Could not decode attribute arguments.*/)]
		private class XRayRenderer__ctor__Patch
		{
			private static void Postfix(XRayRenderer __instance)
			{
				try
				{
					if ((Object)(object)__instance != (Object)null && __instance.instanceCount < 16000)
					{
						__instance.instanceCount = 16000;
					}
				}
				catch
				{
				}
			}
		}

		private const uint BiotrackerGearCategoryId = 9u;

		private const int MaxRaysPerFrame = 180;

		private const int RendererInstanceCount = 16000;

		public override string Name => "LiDaR Biotracker";

		public override bool InlineSettingsIntoParentMenu => true;

		public override bool RequiresRestart => false;

		public static ILocalizationService Localization { get; set; }

		[FeatureConfig]
		public static MapperTrackerSettings Settings { get; set; }

		public override void Init()
		{
			ClassInjector.RegisterTypeInIl2Cpp<MapperTrackerController>(false);
			MapperTrackerManager.Setup();
		}

		public override void OnEnable()
		{
		}

		public override void Update()
		{
			MapperTrackerController.TickLocalBatteryFromFeature();
			EntityXRayHighlight.Tick();
		}

		internal static bool CanDoMapper(ItemEquippable itemEquippable)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			if ((Object)(object)itemEquippable == (Object)null || ((Item)itemEquippable).ItemDataBlock == null || itemEquippable.GearCategoryData == null)
			{
				return false;
			}
			if ((int)((Item)itemEquippable).ItemDataBlock.inventorySlot != 3)
			{
				return false;
			}
			return ((GameDataBlockBase<GearCategoryDataBlock>)(object)itemEquippable.GearCategoryData).persistentID == 9;
		}
	}
}
namespace Hikaria.MapperTracker.Controllers
{
	internal static class BatteryScreenUI
	{
		private class ScreenFx
		{
			public bool OfflineVisualActive;

			public bool RestoreGlitchActive;

			public bool CleanedLegacy;

			public int RestoreFramesLeft;

			public bool SavedCols;

			public Color SavedColEnemy;

			public Color SavedPulseStart;

			public Color SavedPulseEnd;

			public float SavedScanConeDotMin = 0.5f;

			public float GlitchStartUnscaled;

			public float RestoreGlitchStartUnscaled;

			public int LastGlitchSoundBit = -1;

			public bool PlayedInitialShortSound;
		}

		private const string DepleteGlitchPattern = "10101010100101001010000000";

		private const string RestoreGlitchPattern = "0010010100101010010111111";

		private const float GlitchBitSeconds = 0.09f;

		private static readonly Color Hidden = new Color(0f, 0f, 0f, 0f);

		private static readonly Dictionary<int, ScreenFx> s_fx = new Dictionary<int, ScreenFx>();

		private static float s_lastSpamShortSound = -10f;

		public static float DepleteGlitchDuration => (float)"10101010100101001010000000".Length * 0.09f;

		public static float RestoreGlitchDuration => (float)"0010010100101010010111111".Length * 0.09f;

		public static float DepleteGlitchBitSeconds => 0.09f;

		public static int DepleteGlitchBitCount => "10101010100101001010000000".Length;

		public static bool IsDepleteGlitchBitOn(float startUnscaled)
		{
			return IsGlitchBitOn(startUnscaled, "10101010100101001010000000");
		}

		public static bool IsDepleteGlitchFinished(float startUnscaled)
		{
			return IsGlitchPatternDone(startUnscaled, "10101010100101001010000000");
		}

		public static bool IsDepleteGlitchBitOnForPart(float startUnscaled, int partIndex)
		{
			float num = Time.unscaledTime - startUnscaled;
			int num2 = Mathf.FloorToInt(num / 0.09f) + partIndex;
			if (num2 < 0)
			{
				return false;
			}
			if (num >= (float)"10101010100101001010000000".Length * 0.09f)
			{
				return false;
			}
			int index = num2 % "10101010100101001010000000".Length;
			return "10101010100101001010000000"[index] == '1';
		}

		public static void Update(EnemyScanner scanner, BatterySystem.State state)
		{
			if ((Object)(object)((scanner != null) ? scanner.m_screen : null) == (Object)null)
			{
				return;
			}
			ScreenFx screenFx = Ensure(scanner);
			if (!screenFx.CleanedLegacy)
			{
				DestroyLegacyOverlays(scanner);
				screenFx.CleanedLegacy = true;
			}
			ForceScreenAssemblyOn(scanner);
			if (IsMapperScanner(scanner))
			{
				HideHologram(scanner);
			}
			float normalized = Mathf.Clamp01(state.Charge / 100f);
			bool isOffline = state.IsOffline;
			bool flag = isOffline && state.GlitchRemaining > 0f;
			bool flag2 = !isOffline && screenFx.RestoreGlitchActive;
			bool glitching = flag || flag2;
			ApplyBatteryReadout(scanner, normalized, glitching, isOffline && !flag, state.Charge);
			if (isOffline)
			{
				if (!screenFx.OfflineVisualActive)
				{
					SaveScannerColors(scanner, screenFx);
					screenFx.GlitchStartUnscaled = Time.unscaledTime;
					screenFx.OfflineVisualActive = true;
					screenFx.RestoreGlitchActive = false;
					screenFx.LastGlitchSoundBit = -1;
					TryPlayDepleteSting(scanner, state);
				}
				bool flag3 = flag && IsGlitchBitOn(screenFx.GlitchStartUnscaled, "10101010100101001010000000");
				ApplyTempColEnemy(scanner, screenFx, flag3);
				if (flag)
				{
					TickGlitchSound(scanner, screenFx, screenFx.GlitchStartUnscaled, "10101010100101001010000000");
				}
				if (flag && flag3)
				{
					ShowHologram(scanner);
				}
				else if (!flag)
				{
					HideHologram(scanner);
				}
			}
			else if (screenFx.OfflineVisualActive)
			{
				screenFx.OfflineVisualActive = false;
				StartRestoreGlitch(scanner, screenFx);
			}
			else if (screenFx.RestoreGlitchActive)
			{
				bool flag4 = IsGlitchBitOn(screenFx.RestoreGlitchStartUnscaled, "0010010100101010010111111");
				ApplyTempColEnemy(scanner, screenFx, flag4);
				TickGlitchSound(scanner, screenFx, screenFx.RestoreGlitchStartUnscaled, "0010010100101010010111111");
				if (flag4)
				{
					ShowHologram(scanner);
				}
				if (IsGlitchPatternDone(screenFx.RestoreGlitchStartUnscaled, "0010010100101010010111111"))
				{
					screenFx.RestoreGlitchActive = false;
					screenFx.RestoreFramesLeft = 90;
					BeginRestore(scanner, screenFx);
					ForceRescan(scanner);
				}
			}
			else if (screenFx.RestoreFramesLeft > 0)
			{
				ForceRescan(scanner);
				screenFx.RestoreFramesLeft--;
				if (screenFx.RestoreFramesLeft <= 0)
				{
					FinishRestore(scanner, screenFx);
				}
			}
		}

		public static void ApplyDotColorIfOffline(EnemyScanner scanner, EnemyAgent enemy, EnemyScannerDataObject data)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)enemy == (Object)null)
			{
				return;
			}
			object obj;
			if (scanner == null)
			{
				obj = null;
			}
			else
			{
				PlayerAgent owner = ((Item)scanner).Owner;
				obj = ((owner != null) ? owner.Owner : null);
			}
			if ((Object)obj == (Object)null || !((Item)scanner).Owner.Owner.IsLocal)
			{
				return;
			}
			ScreenFx screenFx = Ensure(scanner);
			BatterySystem.State state = BatterySystem.Get(((Item)scanner).Owner.Owner.Lookup);
			bool flag;
			if (state.IsOffline)
			{
				flag = state.GlitchRemaining > 0f && IsGlitchBitOn(screenFx.GlitchStartUnscaled, "10101010100101001010000000");
			}
			else
			{
				if (!screenFx.RestoreGlitchActive)
				{
					return;
				}
				flag = IsGlitchBitOn(screenFx.RestoreGlitchStartUnscaled, "0010010100101010010111111");
			}
			PaintMatOnly(data, flag ? enemy.m_scannerColor : Hidden);
		}

		public static void ClearShortCircuitVisual(EnemyScanner scanner)
		{
			if (!((Object)(object)scanner == (Object)null))
			{
				ScreenFx screenFx = Ensure(scanner);
				ForceScreenAssemblyOn(scanner);
				screenFx.OfflineVisualActive = false;
				if (!screenFx.SavedCols)
				{
					SaveScannerColors(scanner, screenFx);
				}
				StartRestoreGlitch(scanner, screenFx);
			}
		}

		public static void DestroyFor(EnemyScanner scanner)
		{
			if ((Object)(object)scanner == (Object)null)
			{
				return;
			}
			PlayerAgent owner = ((Item)scanner).Owner;
			SNet_Player val = ((owner != null) ? owner.Owner : null);
			if ((Object)(object)val != (Object)null && val.IsLocal && BatterySystem.IsOffline(val.Lookup))
			{
				DestroyLegacyOverlays(scanner);
				return;
			}
			int instanceID = ((Object)scanner).GetInstanceID();
			if (s_fx.TryGetValue(instanceID, out var value))
			{
				FinishRestore(scanner, value);
				ShowHologram(scanner);
				s_fx.Remove(instanceID);
			}
			DestroyLegacyOverlays(scanner);
		}

		public static bool IsRebooting(EnemyScanner scanner)
		{
			if ((Object)(object)scanner == (Object)null)
			{
				return false;
			}
			ScreenFx screenFx = Ensure(scanner);
			if (!screenFx.RestoreGlitchActive)
			{
				return screenFx.RestoreFramesLeft > 0;
			}
			return true;
		}

		public static void PlaySpamShortCircuit(EnemyScanner scanner)
		{
			if (!((Object)(object)scanner == (Object)null) && Hikaria.MapperTracker.Features.MapperTracker.Settings != null && Hikaria.MapperTracker.Features.MapperTracker.Settings.EnableShortCircuitSound && !(Time.unscaledTime - s_lastSpamShortSound < 0.18f))
			{
				s_lastSpamShortSound = Time.unscaledTime;
				PlayInitialShortCircuit(scanner);
				PlaySpark(scanner);
			}
		}

		private static void StartRestoreGlitch(EnemyScanner scanner, ScreenFx fx)
		{
			fx.RestoreGlitchActive = true;
			fx.RestoreGlitchStartUnscaled = Time.unscaledTime;
			fx.RestoreFramesLeft = 0;
			fx.LastGlitchSoundBit = -1;
			fx.PlayedInitialShortSound = true;
			ShowHologram(scanner);
		}

		private static void TryPlayDepleteSting(EnemyScanner scanner, BatterySystem.State state)
		{
			ScreenFx screenFx = Ensure(scanner);
			if (state.DepleteStingPlayed)
			{
				screenFx.PlayedInitialShortSound = true;
				return;
			}
			PlayInitialShortCircuit(scanner);
			screenFx.PlayedInitialShortSound = true;
			state.DepleteStingPlayed = true;
			object obj;
			if (scanner == null)
			{
				obj = null;
			}
			else
			{
				PlayerAgent owner = ((Item)scanner).Owner;
				obj = ((owner != null) ? owner.Owner : null);
			}
			SNet_Player val = (SNet_Player)obj;
			if ((Object)(object)val != (Object)null)
			{
				BatterySystem.Set(val.Lookup, state);
			}
		}

		private static void TickGlitchSound(EnemyScanner scanner, ScreenFx fx, float startUnscaled, string pattern)
		{
			if (Hikaria.MapperTracker.Features.MapperTracker.Settings == null || !Hikaria.MapperTracker.Features.MapperTracker.Settings.EnableShortCircuitSound)
			{
				return;
			}
			int num = Mathf.FloorToInt((Time.unscaledTime - startUnscaled) / 0.09f);
			if (num >= 0 && num < pattern.Length && num != fx.LastGlitchSoundBit)
			{
				fx.LastGlitchSoundBit = num;
				if (pattern[num] == '1' && (num <= 0 || pattern[num - 1] != '1'))
				{
					PlaySpark(scanner);
				}
			}
		}

		private static void PlayInitialShortCircuit(EnemyScanner scanner)
		{
			if (Hikaria.MapperTracker.Features.MapperTracker.Settings == null || !Hikaria.MapperTracker.Features.MapperTracker.Settings.EnableShortCircuitSound)
			{
				return;
			}
			try
			{
				CellSoundPlayer localSound = GetLocalSound(scanner);
				if (localSound != null)
				{
					SharedUtils.SafePost(localSound, EVENTS.BATTERY_STATION_POWERDOWN_FAILURE, true);
				}
			}
			catch
			{
			}
		}

		private static void PlaySpark(EnemyScanner scanner)
		{
			try
			{
				CellSoundPlayer localSound = GetLocalSound(scanner);
				if (localSound != null)
				{
					SharedUtils.SafePost(localSound, EVENTS.WELD_SPARK, true);
				}
			}
			catch
			{
			}
		}

		private static CellSoundPlayer GetLocalSound(EnemyScanner scanner)
		{
			PlayerAgent val = ((scanner != null) ? ((Item)scanner).Owner : null);
			if (((val != null) ? val.Sound : null) != null)
			{
				return val.Sound;
			}
			PlayerAgent localPlayerAgent = PlayerManager.GetLocalPlayerAgent();
			if (localPlayerAgent == null)
			{
				return null;
			}
			return localPlayerAgent.Sound;
		}

		private static void ApplyTempColEnemy(EnemyScanner scanner, ScreenFx fx, bool show)
		{
			//IL_0018: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (fx.SavedCols)
			{
				show = false;
				scanner.m_colEnemy = (show ? fx.SavedColEnemy : Hidden);
				scanner.m_colPulseStart = (show ? fx.SavedPulseStart : Hidden);
				scanner.m_colPulseEnd = (show ? fx.SavedPulseEnd : Hidden);
			}
		}

		private static bool IsGlitchBitOn(float startUnscaled, string pattern)
		{
			int num = Mathf.FloorToInt((Time.unscaledTime - startUnscaled) / 0.09f);
			if (num < 0 || num >= pattern.Length)
			{
				return false;
			}
			return pattern[num] == '1';
		}

		private static bool IsGlitchPatternDone(float startUnscaled, string pattern)
		{
			return Time.unscaledTime - startUnscaled >= (float)pattern.Length * 0.09f;
		}

		private static ScreenFx Ensure(EnemyScanner scanner)
		{
			int instanceID = ((Object)scanner).GetInstanceID();
			if (!s_fx.TryGetValue(instanceID, out var value))
			{
				value = new ScreenFx();
				s_fx[instanceID] = value;
			}
			return value;
		}

		private static void SaveScannerColors(EnemyScanner scanner, ScreenFx fx)
		{
			//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_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_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)
			if (!fx.SavedCols)
			{
				fx.SavedColEnemy = scanner.m_colEnemy;
				fx.SavedPulseStart = scanner.m_colPulseStart;
				fx.SavedPulseEnd = scanner.m_colPulseEnd;
				fx.SavedScanConeDotMin = scanner.m_scanConeDotMin;
				fx.SavedCols = true;
			}
		}

		private static void PaintMatOnly(EnemyScannerDataObject data, Color color)
		{
			//IL_0033: 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)
			try
			{
				if (((data != null) ? data.m_matProp : null) != null)
				{
					int color2 = EnemyScannerGraphics._Color;
					if (color2 != 0)
					{
						data.m_matProp.SetColor(color2, color);
					}
					else
					{
						data.m_matProp.SetColor("_Color", color);
					}
				}
			}
			catch
			{
			}
		}

		private static void BeginRestore(EnemyScanner scanner, ScreenFx fx)
		{
			//IL_0021: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			ShowHologram(scanner);
			ForceScreenAssemblyOn(scanner);
			scanner.m_scanConeDotMin = -1f;
			if (fx.SavedCols)
			{
				scanner.m_colEnemy = fx.SavedColEnemy;
				scanner.m_colPulseStart = fx.SavedPulseStart;
				scanner.m_colPulseEnd = fx.SavedPulseEnd;
			}
		}

		private static void FinishRestore(EnemyScanner scanner, ScreenFx fx)
		{
			//IL_001d: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			fx.RestoreGlitchActive = false;
			if (fx.SavedCols)
			{
				scanner.m_scanConeDotMin = fx.SavedScanConeDotMin;
				scanner.m_colEnemy = fx.SavedColEnemy;
				scanner.m_colPulseStart = fx.SavedPulseStart;
				scanner.m_colPulseEnd = fx.SavedPulseEnd;
				fx.SavedCols = false;
			}
			DirtyAllEnemyColors(scanner);
		}

		private static void ForceRescan(EnemyScanner scanner)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PlayerAgent owner = ((Item)scanner).Owner;
				scanner.m_scanConeDotMin = -1f;
				scanner.m_detectedListIndex = 0;
				scanner.m_nodeListIndex = 0;
				scanner.m_nodeListStepsLeft = 1024;
				scanner.RefreshUpdateID();
				scanner.RefreshNodeEnemyList();
				if (((owner != null) ? ((Agent)owner).CourseNode : null) != null)
				{
					List<EnemyAgent> val = new List<EnemyAgent>();
					EnemyScanner.BotGetScanResult(((Agent)owner).CourseNode, ((Agent)owner).Position, val);
					int count = val.Count;
					for (int i = 0; i < count; i++)
					{
						EnemyAgent val2 = val[i];
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						val2.m_hasDirtyScannerColor = true;
						EnemyScannerDataObject scannerData = val2.ScannerData;
						if (scannerData != null)
						{
							scannerData.m_updateID = scanner.m_updateID - 1;
						}
						try
						{
							val2.UpdateScannerData();
						}
						catch
						{
						}
						if (scannerData != null)
						{
							try
							{
								scanner.UpdateAndRenderScannerData(val2, scannerData);
							}
							catch
							{
							}
						}
					}
				}
				DirtyAllEnemyColors(scanner);
				scanner.UpdateDetectedEnemies(1024);
				EnemyScannerGraphics graphics = scanner.m_graphics;
				if (graphics != null)
				{
					graphics.ResetTargetsCmd();
				}
				scanner.UpdateDetectedEnemies(1024);
				EnemyScannerGraphics graphics2 = scanner.m_graphics;
				if (graphics2 != null)
				{
					graphics2.Render();
				}
			}
			catch
			{
			}
		}

		private static void DirtyAllEnemyColors(EnemyScanner scanner)
		{
			DirtyList(scanner.m_enemiesDetected);
			DirtyList(scanner.m_enemiesInNodes);
		}

		private static void DirtyList(List<EnemyAgent> list)
		{
			if (list == null)
			{
				return;
			}
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				EnemyAgent val = list[i];
				if (!((Object)(object)val == (Object)null))
				{
					val.m_hasDirtyScannerColor = true;
					try
					{
						val.UpdateScannerData();
					}
					catch
					{
					}
				}
			}
		}

		private static void ApplyBatteryReadout(EnemyScanner scanner, float normalized, bool glitching, bool rebooting, float charge)
		{
			EnemyScannerScreen screen = scanner.m_screen;
			if (!((Object)(object)screen == (Object)null))
			{
				string text;
				if (glitching)
				{
					text = "<#FF3333>BAT ERR</color>";
				}
				else if (rebooting)
				{
					text = $"<#888>REBOOT {charge:0}%</color>";
				}
				else
				{
					string value = ((normalized > 0.35f) ? "#3FF28C" : ((normalized > 0.15f) ? "#FFBF26" : "#FF4433"));
					text = $"<{value}>BAT {charge:0}%</color>";
				}
				try
				{
					screen.SetStatusText(text);
				}
				catch
				{
				}
				if ((Object)(object)screen.m_statusTextCharge != (Object)null)
				{
					((TMP_Text)screen.m_statusTextCharge).SetText(text, true);
				}
			}
		}

		private static void HideHologram(EnemyScanner scanner)
		{
			HologramGraphics hologramGraphics = scanner.m_hologramGraphics;
			SetActiveSafe((hologramGraphics != null) ? ((Component)hologramGraphics).gameObject : null, active: false);
			HologramGraphics hologramGraphics2 = scanner.m_hologramGraphics;
			if (((hologramGraphics2 != null) ? hologramGraphics2.m_holoParts : null) == null)
			{
				return;
			}
			Enumerator<HologramGraphicsPart> enumerator = scanner.m_hologramGraphics.m_holoParts.GetEnumerator();
			while (enumerator.MoveNext())
			{
				HologramGraphicsPart current = enumerator.Current;
				if ((Object)(object)current != (Object)null)
				{
					SetActiveSafe(((Component)current).gameObject, active: false);
				}
			}
		}

		private static void ShowHologram(EnemyScanner scanner)
		{
			if (IsMapperScanner(scanner))
			{
				HideHologram(scanner);
				return;
			}
			HologramGraphics hologramGraphics = scanner.m_hologramGraphics;
			SetActiveSafe((hologramGraphics != null) ? ((Component)hologramGraphics).gameObject : null, active: true);
			HologramGraphics hologramGraphics2 = scanner.m_hologramGraphics;
			if (((hologramGraphics2 != null) ? hologramGraphics2.m_holoParts : null) == null)
			{
				return;
			}
			Enumerator<HologramGraphicsPart> enumerator = scanner.m_hologramGraphics.m_holoParts.GetEnumerator();
			while (enumerator.MoveNext())
			{
				HologramGraphicsPart current = enumerator.Current;
				if ((Object)(object)current != (Object)null)
				{
					SetActiveSafe(((Component)current).gameObject, active: true);
				}
			}
		}

		private static bool IsMapperScanner(EnemyScanner scanner)
		{
			if (MapperTrackerManager.TryGetControllerForScanner(scanner, out var controller))
			{
				return (Object)(object)controller != (Object)null;
			}
			return false;
		}

		private static void ForceScreenAssemblyOn(EnemyScanner scanner)
		{
			Transform scannerObjRoot = scanner.m_scannerObjRoot;
			SetActiveSafe((scannerObjRoot != null) ? ((Component)scannerObjRoot).gameObject : null, active: true);
			if ((Object)(object)scanner.m_screen != (Object)null)
			{
				SetActiveSafe(((Component)scanner.m_screen).gameObject, active: true);
			}
			EnemyScannerScreen screen = scanner.m_screen;
			if ((Object)(object)((screen != null) ? screen.m_guixRoot : null) != (Object)null)
			{
				SetActiveSafe(((Component)scanner.m_screen.m_guixRoot).gameObject, active: true);
			}
			if ((Object)(object)scanner.m_graphics != (Object)null)
			{
				SetActiveSafe(((Component)scanner.m_graphics).gameObject, active: true);
			}
			EnemyScannerGraphics graphics = scanner.m_graphics;
			if ((Object)(object)((graphics != null) ? graphics.m_display : null) != (Object)null)
			{
				SetActiveSafe(((Component)scanner.m_graphics.m_display).gameObject, active: true);
				scanner.m_graphics.m_display.enabled = true;
			}
		}

		private static void DestroyLegacyOverlays(EnemyScanner scanner)
		{
			if ((Object)(object)scanner == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<Transform> componentsInChildren = ((Component)scanner).GetComponentsInChildren<Transform>(true);
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in componentsInChildren)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = ((Object)item).name ?? string.Empty;
				if (!text.StartsWith("MapperTracker_"))
				{
					switch (text)
					{
					case "MT_LcdBlackPlate":
					case "BatteryPanel":
					case "BatteryBg":
					case "BatteryFill":
					case "BatteryValue":
					case "BatteryTitle":
					case "ScreenBlackout":
						break;
					default:
						continue;
					}
				}
				list.Add(((Component)item).gameObject);
			}
			foreach (GameObject item2 in list)
			{
				if ((Object)(object)item2 != (Object)null)
				{
					Object.Destroy((Object)(object)item2);
				}
			}
		}

		private static void SetActiveSafe(GameObject go, bool active)
		{
			if ((Object)(object)go != (Object)null && go.activeSelf != active)
			{
				go.SetActive(active);
			}
		}
	}
	internal static class BatterySystem
	{
		public struct State
		{
			public float Charge;

			public bool IsOffline;

			public float GlitchRemaining;

			public bool DepleteStingPlayed;
		}

		public const float MaxCharge = 100f;

		private static readonly Dictionary<ulong, State> s_states = new Dictionary<ulong, State>();

		public static State Get(ulong lookup)
		{
			if (!s_states.TryGetValue(lookup, out var value))
			{
				value = new State
				{
					Charge = 100f
				};
				s_states[lookup] = value;
			}
			return value;
		}

		public static void Set(ulong lookup, State state)
		{
			s_states[lookup] = state;
		}

		public static void Clear(ulong lookup)
		{
			s_states.Remove(lookup);
		}

		public static bool TrySpend(ulong lookup, float costPercent, float glitchDuration, out State state, out bool justWentOffline)
		{
			justWentOffline = false;
			state = Get(lookup);
			if (state.IsOffline)
			{
				return false;
			}
			state.Charge = Mathf.Max(0f, state.Charge - Mathf.Max(0f, costPercent));
			if (state.Charge <= 0.01f)
			{
				state.Charge = 0f;
				state.IsOffline = true;
				state.GlitchRemaining = Mathf.Max(BatteryScreenUI.DepleteGlitchDuration, glitchDuration);
				state.DepleteStingPlayed = false;
				justWentOffline = true;
			}
			Set(lookup, state);
			return true;
		}

		public static void TickWhileActive(ulong lookup, bool mapperActive, float batteryDurationSeconds, float rechargePerSecond, float glitchDuration, float dt, out State state, out bool justWentOffline)
		{
			justWentOffline = false;
			state = Get(lookup);
			if (state.IsOffline)
			{
				if (state.GlitchRemaining > 0f)
				{
					state.GlitchRemaining = Mathf.Max(0f, state.GlitchRemaining - dt);
				}
				state.Charge = Mathf.Min(100f, state.Charge + rechargePerSecond * dt);
				if (state.Charge >= 99.99f)
				{
					state.Charge = 100f;
					state.IsOffline = false;
					state.GlitchRemaining = 0f;
					state.DepleteStingPlayed = false;
				}
				Set(lookup, state);
				return;
			}
			if (mapperActive)
			{
				float num = 100f / Mathf.Max(1f, batteryDurationSeconds);
				state.Charge = Mathf.Max(0f, state.Charge - num * dt);
				if (state.Charge <= 0.01f)
				{
					state.Charge = 0f;
					state.IsOffline = true;
					state.GlitchRemaining = Mathf.Max(BatteryScreenUI.DepleteGlitchDuration, glitchDuration);
					state.DepleteStingPlayed = false;
					justWentOffline = true;
				}
			}
			else
			{
				state.Charge = Mathf.Min(100f, state.Charge + rechargePerSecond * dt);
			}
			Set(lookup, state);
		}

		public static void TickRecharge(ulong lookup, bool allowRecharge, float rechargePerSecond, float glitchDuration, float dt, out State state, out bool justWentOffline)
		{
			justWentOffline = false;
			state = Get(lookup);
			if (state.IsOffline)
			{
				if (state.GlitchRemaining > 0f)
				{
					state.GlitchRemaining = Mathf.Max(0f, state.GlitchRemaining - dt);
				}
				state.Charge = Mathf.Min(100f, state.Charge + rechargePerSecond * dt);
				if (state.Charge >= 99.99f)
				{
					state.Charge = 100f;
					state.IsOffline = false;
					state.GlitchRemaining = 0f;
					state.DepleteStingPlayed = false;
				}
				Set(lookup, state);
			}
			else
			{
				if (allowRecharge)
				{
					state.Charge = Mathf.Min(100f, state.Charge + rechargePerSecond * dt);
				}
				Set(lookup, state);
			}
		}

		public static void Tick(ulong lookup, bool mapperActive, float drainPerSecond, float rechargePerSecond, float glitchDuration, float dt, out State state, out bool justWentOffline)
		{
			TickRecharge(lookup, !mapperActive, rechargePerSecond, glitchDuration, dt, out state, out justWentOffline);
		}

		public static bool IsOffline(ulong lookup)
		{
			return Get(lookup).IsOffline;
		}

		public static bool IsGlitching(ulong lookup)
		{
			State state = Get(lookup);
			if (state.IsOffline)
			{
				return state.GlitchRemaining > 0f;
			}
			return false;
		}
	}
	internal static class BiotrackerFpVisual
	{
		public static void Apply(ItemEquippable tool)
		{
			if ((Object)(object)tool == (Object)null)
			{
				return;
			}
			try
			{
				SuppressFrontProjector((EnemyScanner)(((object)((tool is EnemyScanner) ? tool : null)) ?? ((object)((Component)tool).GetComponent<EnemyScanner>())));
			}
			catch
			{
			}
		}

		public static void Clear(ItemEquippable tool)
		{
		}

		public static void SuppressFrontProjector(EnemyScanner scanner)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scanner == (Object)null)
			{
				return;
			}
			try
			{
				scanner.m_colEnemy = new Color(0f, 0f, 0f, 0f);
				scanner.m_colPulseStart = new Color(0f, 0f, 0f, 0f);
				scanner.m_colPulseEnd = new Color(0f, 0f, 0f, 0f);
			}
			catch
			{
			}
			try
			{
				HologramGraphics hologramGraphics = scanner.m_hologramGraphics;
				SetActiveSafe((hologramGraphics != null) ? ((Component)hologramGraphics).gameObject : null, on: false);
				HologramGraphics hologramGraphics2 = scanner.m_hologramGraphics;
				if (((hologramGraphics2 != null) ? hologramGraphics2.m_holoParts : null) != null)
				{
					Enumerator<HologramGraphicsPart> enumerator = scanner.m_hologramGraphics.m_holoParts.GetEnumerator();
					while (enumerator.MoveNext())
					{
						HologramGraphicsPart current = enumerator.Current;
						if (!((Object)(object)current == (Object)null))
						{
							try
							{
								SetActiveSafe(((Component)current).gameObject, on: false);
							}
							catch
							{
							}
						}
					}
				}
			}
			catch
			{
			}
			try
			{
				Il2CppArrayBase<ParticleSystem> componentsInChildren = ((Component)((Component)scanner).transform).GetComponentsInChildren<ParticleSystem>(true);
				if (componentsInChildren == null)
				{
					return;
				}
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					ParticleSystem val = componentsInChildren[i];
					if (!((Object)(object)val == (Object)null))
					{
						string name = ((Object)((Component)val).gameObject).name;
						if (name.IndexOf("screen", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("lcd", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("display", StringComparison.OrdinalIgnoreCase) < 0)
						{
							val.Stop(true, (ParticleSystemStopBehavior)0);
							((Component)val).gameObject.SetActive(false);
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void SetActiveSafe(GameObject go, bool on)
		{
			if ((Object)(object)go != (Object)null && go.activeSelf != on)
			{
				go.SetActive(on);
			}
		}
	}
	internal static class BrightSurfaceDots
	{
		private const float MinHitDistance = 0.55f;

		private const int MaxRays = 96;

		private const int MaxPenetrations = 8;

		private const float SkinOffset = 0.03f;

		private const float BeamHalfWidthDeg = 2.2f;

		private static readonly RaycastHit[] s_hits = (RaycastHit[])(object)new RaycastHit[24];

		private static bool s_played;

		public static void ResetSession()
		{
			s_played = false;
		}

		public static void EmitSwipe(XRays xrays, int rayCount, float phase01, Color washColor, float washSize, Color brightColor, float brightSize, float maxDistance, float fovDegrees, bool axisX)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: 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_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)xrays == (Object)null || rayCount <= 0)
			{
				return;
			}
			XRayRenderer val = EnsureRenderer(xrays);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			try
			{
				val.alignToVelocity = false;
				val.alignToView = true;
				val.range = Mathf.Max(1f, maxDistance);
				val.mode = 0;
				if (!s_played)
				{
					val.Play();
					s_played = true;
				}
			}
			catch
			{
			}
			Transform transform = ((Component)xrays).transform;
			Vector3 origin = transform.position + transform.forward * 0.4f;
			Vector3 forward = transform.forward;
			Vector3 right = transform.right;
			Vector3 up = transform.up;
			float num = Mathf.Max(1f, fovDegrees) * 0.5f;
			float num2 = (Mathf.Clamp01(phase01) * 2f - 1f) * num;
			float maxDist = Mathf.Max(1f, maxDistance);
			int mask = ResolveMask();
			int num3 = Mathf.Clamp(rayCount, 1, 96);
			washColor.a = Mathf.Clamp(washColor.a, 0.08f, 0.35f);
			brightColor.a = 1f;
			float washSize2 = Mathf.Clamp(washSize, 0.7f, 2f);
			float brightSize2 = Mathf.Clamp(brightSize, 0.6f, 2.2f);
			for (int i = 0; i < num3; i++)
			{
				float num4 = (Random.value * 2f - 1f) * 2.2f;
				float num5 = (Random.value * 2f - 1f) * num;
				float num6 = num2 + num4;
				Vector3 val2;
				Vector3 normalized;
				if (axisX)
				{
					val2 = Quaternion.AngleAxis(num6, up) * Quaternion.AngleAxis(num5 * 0.35f, right) * forward;
					normalized = ((Vector3)(ref val2)).normalized;
				}
				else
				{
					val2 = Quaternion.AngleAxis(num6, right) * Quaternion.AngleAxis(num5 * 0.35f, up) * forward;
					normalized = ((Vector3)(ref val2)).normalized;
				}
				EmitPiercing(val, origin, normalized, maxDist, mask, washColor, washSize2, brightColor, brightSize2);
			}
		}

		public static void EmitAllHits(XRays xrays, int rayCount, Color color, float size, float maxDistance, float fovDegrees)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			EmitSwipe(xrays, rayCount, Random.value, color, size, color, size, maxDistance, fovDegrees, axisX: true);
		}

		private static XRayRenderer EnsureRenderer(XRays xrays)
		{
			XRayRenderer renderer = xrays.m_renderer;
			if ((Object)(object)renderer != (Object)null)
			{
				return renderer;
			}
			try
			{
				renderer = ((Component)xrays).gameObject.GetComponent<XRayRenderer>();
			}
			catch
			{
				renderer = null;
			}
			if ((Object)(object)renderer != (Object)null)
			{
				xrays.m_renderer = renderer;
			}
			return renderer;
		}

		private static void EmitPiercing(XRayRenderer renderer, Vector3 origin, Vector3 dir, float maxDist, int mask, Color wash, float washSize, Color bright, float brightSize)
		{
			//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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//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)
			int num;
			try
			{
				num = Physics.RaycastNonAlloc(origin, dir, Il2CppStructArray<RaycastHit>.op_Implicit(s_hits), maxDist, mask, (QueryTriggerInteraction)1);
			}
			catch
			{
				return;
			}
			if (num <= 0)
			{
				return;
			}
			for (int i = 1; i < num; i++)
			{
				RaycastHit val = s_hits[i];
				int num2 = i - 1;
				while (num2 >= 0 && ((RaycastHit)(ref s_hits[num2])).distance > ((RaycastHit)(ref val)).distance)
				{
					s_hits[num2 + 1] = s_hits[num2];
					num2--;
				}
				s_hits[num2 + 1] = val;
			}
			int num3 = 0;
			for (int j = 0; j < num; j++)
			{
				if (num3 >= 8)
				{
					break;
				}
				RaycastHit val2 = s_hits[j];
				if (!((Object)(object)((RaycastHit)(ref val2)).collider == (Object)null) && !(((RaycastHit)(ref val2)).distance < 0.55f))
				{
					Vector3 val3 = ((RaycastHit)(ref val2)).point + ((RaycastHit)(ref val2)).normal * 0.03f;
					try
					{
						renderer.Emit(val3, ((RaycastHit)(ref val2)).normal, wash, washSize, 0f);
						renderer.Emit(val3, ((RaycastHit)(ref val2)).normal, bright, brightSize, 0f);
						num3++;
					}
					catch
					{
					}
				}
			}
		}

		private static int ResolveMask()
		{
			int num = -1;
			try
			{
				int mASK_DEFAULT = LayerManager.MASK_DEFAULT;
				if (mASK_DEFAULT != 0)
				{
					num = mASK_DEFAULT;
				}
			}
			catch
			{
			}
			try
			{
				int mASK_BULLETWEAPON_RAY = LayerManager.MASK_BULLETWEAPON_RAY;
				if (mASK_BULLETWEAPON_RAY != 0)
				{
					num |= mASK_BULLETWEAPON_RAY;
				}
			}
			catch
			{
			}
			try
			{
				int lAYER_FIRST_PERSON_ITEM = LayerManager.LAYER_FIRST_PERSON_ITEM;
				if (lAYER_FIRST_PERSON_ITEM >= 0)
				{
					num &= ~(1 << lAYER_FIRST_PERSON_ITEM);
				}
			}
			catch
			{
			}
			if (num != 0)
			{
				return num;
			}
			return -1;
		}
	}
	internal static class EntityXRayHighlight
	{
		private enum ItemKind
		{
			Switch,
			Terminal,
			Locker,
			Booster
		}

		private readonly struct HighlightKey : IEquatable<HighlightKey>
		{
			public readonly ulong Source;

			public readonly int RootId;

			public HighlightKey(ulong source, int rootId)
			{
				Source = source;
				RootId = rootId;
			}

			public bool Equals(HighlightKey other)
			{
				if (Source == other.Source)
				{
					return RootId == other.RootId;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is HighlightKey other)
				{
					return Equals(other);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return ((int)Source * 397) ^ RootId;
			}
		}

		private sealed class HitboxLink
		{
			public Transform Dummy;

			public Transform Visual;

			public Collider SourceCollider;

			public List<Renderer> Renderers;
		}

		private class LiveEntry
		{
			public ulong SourceOwner;

			public bool IsLocalHolder;

			public Transform Root;

			public Vector3 LastPos;

			public Color BaseColor;

			public float ExpiresAt;

			public GameObject OverlayRoot;

			public bool IsMarker;

			public bool IsHitbox;

			public MeshRenderer MarkerRenderer;

			public Material MarkerMaterial;

			public List<Renderer> MeshRenderers;

			public List<HitboxLink> Hitboxes;

			public Vector3 GlowOrigin;

			public Vector3 GlowForward;

			public Vector3 GlowRight;

			public Vector3 GlowUp;

			public float GlowFov;

			public float GlowMaxDist;

			public bool GlowAxisX;

			public bool IsEnemy;

			public float FadeStartedAt;

			public float FadeDuration;

			public float FadeStartIntensity;

			public bool HasBeenRevealed;

			public float LastGlowIntensity;

			public float RevealStartedAt;

			public bool ShortGlitch;

			public float ShortGlitchStartAt;

			public float ShortGlitchEndAt;
		}

		public const float SweepCyclesPerSec = 0.5f;

		private const float TtlSeconds = 0.55f;

		private static float s_enemyHighlightTtl = 1f;

		private static float s_interactableHighlightTtl = 10f;

		private const float ScanInterval = 0.12f;

		private const int MaxEntries = 64;

		private const int MaxEnemyHitboxes = 14;

		private const float HitboxPad = 0.48f;

		private const float MarkerScale = 0.16f;

		private const float AlphaMul = 0.12f;

		private const float GlowFloor = 0.22f;

		private const float GlowFadeInSeconds = 0.12f;

		private const float DefaultGlowPhaseLagSeconds = 0.05f;

		private const float GlowSoftSeconds = 1.15f;

		private const float EnemyLingerFadeSeconds = 1f;

		private const string MarkerName = "MT_EnemyMarker";

		private const string MeshOverlayName = "MT_InteractOverlay";

		private const string EnemyHitboxName = "MT_EnemyHitboxes";

		private static bool s_waveGateEnabled = true;

		private static bool s_waveActive;

		private static float s_waveStart;

		private static float s_waveDuration = 2.5f;

		private static float s_waveDistance = 18f;

		private static Vector3 s_waveOrigin;

		private static Vector3 s_waveForward;

		private static readonly Dictionary<HighlightKey, LiveEntry> s_entries = new Dictionary<HighlightKey, LiveEntry>();

		private static readonly List<HighlightKey> s_expireScratch = new List<HighlightKey>();

		private static readonly List<GameObject> s_markerPool = new List<GameObject>();

		private static readonly HashSet<int> s_seenRoots = new HashSet<int>();

		private static readonly HashSet<ulong> s_activeSources = new HashSet<ulong>();

		private static readonly Dictionary<ulong, float> s_nextScanByOwner = new Dictionary<ulong, float>();

		private static readonly List<EnemyAgent> s_scanList = new List<EnemyAgent>();

		private static Material s_templateMat;

		private static Mesh s_sphereMesh;

		private static bool s_matFailed;

		private static float s_swipeSpeed = 0.5f;

		private static ulong s_scanSource;

		private static bool s_scanLocalHolder;

		private static Vector3 s_scanOrigin;

		private static Vector3 s_playerOrigin;

		private static Vector3 s_forward;

		private static Vector3 s_right;

		private static Vector3 s_up;

		private static float s_scanMaxDist = 18f;

		private static float s_fov = 84f;

		private static bool s_swipeAxisX = true;

		private static readonly Color[] s_tvBars = (Color[])(object)new Color[8]
		{
			new Color(0.55f, 0.55f, 0.55f, 1f),
			new Color(0.55f, 0.55f, 0.12f, 1f),
			new Color(0.12f, 0.55f, 0.55f, 1f),
			new Color(0.12f, 0.55f, 0.12f, 1f),
			new Color(0.55f, 0.12f, 0.55f, 1f),
			new Color(0.55f, 0.12f, 0.12f, 1f),
			new Color(0.12f, 0.12f, 0.55f, 1f),
			new Color(0.55f, 0.28f, 0.08f, 1f)
		};

		private const float ShortGlitchAlpha = 0.28f;

		private static float EnemyRevealTotalSeconds => 1.27f;

		private static float EnemyTtl => s_enemyHighlightTtl;

		private static float InteractableTtl => s_interactableHighlightTtl;

		public static float CurrentSwipePhase => Mathf.Repeat(Time.time * Mathf.Max(0.01f, s_swipeSpeed), 1f);

		public static float EffectiveSwipePhase
		{
			get
			{
				float num = 0.05f;
				try
				{
					if (Hikaria.MapperTracker.Features.MapperTracker.Settings != null)
					{
						num = Hikaria.MapperTracker.Features.MapperTracker.Settings.EnemyGlowPhaseLagSeconds;
					}
				}
				catch
				{
				}
				float num2 = num * Mathf.Max(0.01f, s_swipeSpeed);
				return Mathf.Repeat(CurrentSwipePhase - num2, 1f);
			}
		}

		public static void SetEnemyHighlightTtl(float seconds)
		{
			s_enemyHighlightTtl = Mathf.Clamp(seconds, 0.35f, 60f);
		}

		public static void BeginEnemyFadeOut(ulong sourceOwner, float seconds = 1f)
		{
			SetSourceActive(sourceOwner, active: false);
			float num = Mathf.Clamp(seconds, 0.25f, 3f);
			float unscaledTime = Time.unscaledTime;
			s_expireScratch.Clear();
			foreach (KeyValuePair<HighlightKey, LiveEntry> s_entry in s_entries)
			{
				LiveEntry value = s_entry.Value;
				if (value != null && s_entry.Key.Source == sourceOwner && value.IsEnemy)
				{
					float num2 = Mathf.Max(value.LastGlowIntensity, value.HasBeenRevealed ? 0.01f : 0f);
					if (!value.HasBeenRevealed || num2 < 0.02f)
					{
						s_expireScratch.Add(s_entry.Key);
						continue;
					}
					value.FadeStartIntensity = Mathf.Clamp01(Mathf.Max(value.LastGlowIntensity, 0.15f));
					value.FadeStartedAt = unscaledTime;
					value.FadeDuration = num;
					value.ExpiresAt = unscaledTime + num;
				}
			}
			for (int i = 0; i < s_expireScratch.Count; i++)
			{
				Release(s_expireScratch[i]);
			}
		}

		public static void SetInteractableHighlightTtl(float seconds)
		{
			s_interactableHighlightTtl = Mathf.Clamp(seconds, 0.25f, 60f);
		}

		public static void SetSourceActive(ulong sourceOwner, bool active)
		{
			if (active)
			{
				s_activeSources.Add(sourceOwner);
			}
			else
			{
				s_activeSources.Remove(sourceOwner);
			}
		}

		public static void AdvanceSwipePhase(float swipeSpeed)
		{
			if (swipeSpeed > 0.01f)
			{
				s_swipeSpeed = swipeSpeed;
			}
		}

		public static void ResetSwipePhase()
		{
		}

		public static void SetWaveGateEnabled(bool enabled)
		{
			s_waveGateEnabled = enabled;
			if (!enabled)
			{
				s_waveActive = false;
			}
		}

		public static void BeginPulseWave(Vector3 feet, Vector3 forward, float duration, float distance)
		{
			//IL_0030: 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)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//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)
			s_waveActive = true;
			s_waveStart = Time.unscaledTime;
			s_waveDuration = Mathf.Max(0.35f, duration);
			s_waveDistance = Mathf.Max(4f, distance);
			s_waveOrigin = feet;
			forward.y = 0f;
			if (((Vector3)(ref forward)).sqrMagnitude < 0.0001f)
			{
				forward = Vector3.forward;
			}
			s_waveForward = ((Vector3)(ref forward)).normalized;
		}

		public static void PulseScan(XRays xrays, bool focused, PlayerAgent ownerHint, ulong sourceOwner, bool isLocalHolder, bool scanEnemies, bool scanInteractables)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: 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)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)xrays == (Object)null || Hikaria.MapperTracker.Features.MapperTracker.Settings == null || !((Component)xrays).gameObject.activeInHierarchy)
			{
				return;
			}
			s_scanSource = sourceOwner;
			s_scanLocalHolder = isLocalHolder;
			UpdateScanBasis(xrays, focused);
			s_playerOrigin = s_scanOrigin;
			if ((Object)(object)ownerHint != (Object)null)
			{
				try
				{
					s_playerOrigin = ((Agent)ownerHint).Position;
				}
				catch
				{
					s_playerOrigin = s_scanOrigin;
				}
			}
			if (scanEnemies && s_waveActive && (Object)(object)ownerHint != (Object)null)
			{
				s_scanOrigin = s_waveOrigin;
				s_forward = s_waveForward;
				Vector3 val = Vector3.Cross(Vector3.up, s_forward);
				s_right = ((Vector3)(ref val)).normalized;
				if (((Vector3)(ref s_right)).sqrMagnitude < 0.0001f)
				{
					s_right = Vector3.right;
				}
				s_up = Vector3.up;
				s_playerOrigin = s_waveOrigin;
			}
			if (!s_nextScanByOwner.TryGetValue(sourceOwner, out var value) || Time.unscaledTime >= value)
			{
				s_nextScanByOwner[sourceOwner] = Time.unscaledTime + ((scanInteractables && !scanEnemies) ? 0.05f : 0.12f);
				float cosHalf = Mathf.Cos(Mathf.Max(1f, s_fov) * 0.6f * ((float)Math.PI / 180f));
				if (scanEnemies)
				{
					Color val2 = ColorEnemy(isLocalHolder);
					val2.a = Mathf.Clamp(val2.a * 0.35f, 0.04f, 0.18f);
					val2.r *= 0.55f;
					val2.g *= 0.55f;
					val2.b *= 0.55f;
					ScanEnemies(ownerHint, s_scanOrigin, s_forward, s_scanMaxDist, cosHalf, val2);
					ScanEnemiesOverlap(s_scanOrigin, s_forward, s_scanMaxDist, cosHalf, val2);
				}
				if (scanInteractables)
				{
					ScanInteractables(s_scanOrigin, s_forward, s_scanMaxDist, cosHalf);
				}
			}
		}

		public static void PulseScan(XRays xrays, bool focused, PlayerAgent ownerHint, ulong sourceOwner, bool isLocalHolder)
		{
			PulseScan(xrays, focused, ownerHint, sourceOwner, isLocalHolder, scanEnemies: true, scanInteractables: true);
		}

		public static void Tick()
		{
			//IL_0137: 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)
			if (s_entries.Count == 0)
			{
				return;
			}
			float time = Time.time;
			float unscaledTime = Time.unscaledTime;
			s_expireScratch.Clear();
			foreach (KeyValuePair<HighlightKey, LiveEntry> s_entry in s_entries)
			{
				LiveEntry value = s_entry.Value;
				if (value == null || (Object)(object)value.Root == (Object)null || (Object)(object)value.OverlayRoot == (Object)null)
				{
					s_expireScratch.Add(s_entry.Key);
					continue;
				}
				if (value.IsEnemy && value.ShortGlitch)
				{
					value.ExpiresAt = Mathf.Max(value.ExpiresAt, value.ShortGlitchEndAt + 0.35f);
				}
				else if (value.IsEnemy && value.RevealStartedAt > 0f && value.FadeStartedAt <= 0f)
				{
					float num = time - value.RevealStartedAt;
					float num2 = EnemyRevealTotalSeconds - num;
					if (num2 > 0f)
					{
						value.ExpiresAt = Mathf.Max(value.ExpiresAt, unscaledTime + num2 + 0.25f);
					}
				}
				if (unscaledTime >= value.ExpiresAt)
				{
					s_expireScratch.Add(s_entry.Key);
					continue;
				}
				try
				{
					value.LastPos = value.Root.position;
				}
				catch
				{
				}
				if (value.IsHitbox)
				{
					if (value.ShortGlitch)
					{
						SyncEnemyHitboxTransforms(value);
					}
					else
					{
						SyncEnemyHitboxes(value);
					}
				}
				ApplyGlow(value, time);
			}
			for (int i = 0; i < s_expireScratch.Count; i++)
			{
				Release(s_expireScratch[i]);
			}
		}

		private static void UpdateScanBasis(XRays xrays, bool focused)
		{
			//IL_0011: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Invalid comparison between Unknown and I4
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Invalid comparison between Unknown and I4
			if ((Object)(object)xrays == (Object)null)
			{
				return;
			}
			Transform transform = ((Component)xrays).transform;
			s_scanOrigin = transform.position;
			s_forward = transform.forward;
			s_right = transform.right;
			s_up = transform.up;
			s_scanMaxDist = Mathf.Max(0.5f, xrays.maxDistance);
			s_fov = Mathf.Max(1f, focused ? xrays.fieldOfViewFocused : xrays.fieldOfView);
			try
			{
				if (Mathf.Abs(xrays.swipeSpeed - 0.5f) > 0.001f)
				{
					xrays.swipeSpeed = 0.5f;
				}
				if ((int)xrays.scanMode != 1)
				{
					xrays.scanMode = (ScanMode)1;
				}
				s_swipeSpeed = xrays.swipeSpeed;
			}
			catch
			{
			}
			try
			{
				s_swipeAxisX = (int)xrays.scanDirection == 0;
			}
			catch
			{
				s_swipeAxisX = true;
			}
		}

		public static void BeginBatteryShortGlitch(ulong sourceOwner, float durationSeconds)
		{
			SetSourceActive(sourceOwner, active: false);
			float unscaledTime = Time.unscaledTime;
			float num = Mathf.Max(BatteryScreenUI.DepleteGlitchDuration, Mathf.Clamp(durationSeconds, 1.2f, 6f));
			float num2 = unscaledTime + num;
			int num3 = 0;
			foreach (KeyValuePair<HighlightKey, LiveEntry> s_entry in s_entries)
			{
				LiveEntry value = s_entry.Value;
				if (value != null && s_entry.Key.Source == sourceOwner && value.IsEnemy && (value.HasBeenRevealed || !(value.LastGlowIntensity < 0.02f)))
				{
					value.ShortGlitch = true;
					value.ShortGlitchStartAt = unscaledTime;
					value.ShortGlitchEndAt = num2;
					value.FadeStartedAt = 0f;
					value.FadeDuration = 0f;
					value.RevealStartedAt = 0f;
					value.HasBeenRevealed = true;
					value.LastGlowIntensity = 1f;
					value.ExpiresAt = num2 + 0.75f;
					num3++;
				}
			}
			if (num3 > 0)
			{
				Logs.LogInfo($"Battery short glitch: {num3} enemy overlay(s) for {durationSeconds:0.00}s");
			}
		}

		public static bool HasActiveShortGlitch(ulong sourceOwner)
		{
			float unscaledTime = Time.unscaledTime;
			foreach (KeyValuePair<HighlightKey, LiveEntry> s_entry in s_entries)
			{
				LiveEntry value = s_entry.Value;
				if (value != null && s_entry.Key.Source == sourceOwner && value.ShortGlitch && unscaledTime < value.ShortGlitchEndAt + 0.5f)
				{
					return true;
				}
			}
			return false;
		}

		public static void ClearForSource(ulong sourceOwner, bool includeShortGlitch = true)
		{
			SetSourceActive(sourceOwner, active: false);
			s_expireScratch.Clear();
			foreach (KeyValuePair<HighlightKey, LiveEntry> s_entry in s_entries)
			{
				if (s_entry.Key.Source == sourceOwner && (includeShortGlitch || s_entry.Value == null || !s_entry.Value.ShortGlitch))
				{
					s_expireScratch.Add(s_entry.Key);
				}
			}
			for (int i = 0; i < s_expireScratch.Count; i++)
			{
				Release(s_expireScratch[i]);
			}
			s_nextScanByOwner.Remove(sourceOwner);
		}

		public static void ClearAll()
		{
			s_expireScratch.Clear();
			foreach (HighlightKey key in s_entries.Keys)
			{
				s_expireScratch.Add(key);
			}
			for (int i = 0; i < s_expireScratch.Count; i++)
			{
				Release(s_expireScratch[i]);
			}
			s_entries.Clear();
			s_nextScanByOwner.Clear();
		}

		private static void ScanEnemies(PlayerAgent ownerHint, Vector3 origin, Vector3 forward, float maxDist, float cosHalf, Color enemyColor)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			PlayerAgent val = ownerHint;
			if ((Object)(object)val == (Object)null)
			{
				try
				{
					val = PlayerManager.GetLocalPlayerAgent();
				}
				catch
				{
					val = null;
				}
			}
			if (((val != null) ? ((Agent)val).CourseNode : null) == null)
			{
				return;
			}
			try
			{
				s_scanList.Clear();
				EnemyScanner.BotGetScanResult(((Agent)val).CourseNode, origin, s_scanList);
			}
			catch
			{
				return;
			}
			int count = s_scanList.Count;
			for (int i = 0; i < count; i++)
			{
				EnemyAgent val2 = s_scanList[i];
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null) && ((Component)val2).gameObject.activeInHierarchy)
				{
					Vector3 position;
					try
					{
						position = val2.Position;
					}
					catch
					{
						position = ((Component)val2).transform.position;
					}
					if (InCone(position, origin, forward, maxDist, cosHalf))
					{
						TouchEnemy(((Component)val2).transform, position, enemyColor);
					}
				}
			}
		}

		private static void ScanEnemiesOverlap(Vector3 origin, Vector3 forward, float maxDist, float cosHalf, Color enemyColor)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			int num = 0;
			try
			{
				num = LayerManager.MASK_ENEMY_DAMAGABLE | LayerManager.MASK_ENEMY | LayerManager.MASK_ENEMY_DEAD;
			}
			catch
			{
				num = -1;
			}
			if (num == 0)
			{
				num = -1;
			}
			Collider[] array;
			try
			{
				array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(origin, maxDist, num, (QueryTriggerInteraction)2));
			}
			catch
			{
				return;
			}
			if (array == null)
			{
				return;
			}
			for (int i = 0; i < array.Length; i++)
			{
				EnemyAgent val = FindEnemy(array[i]);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
				{
					Vector3 position;
					try
					{
						position = val.Position;
					}
					catch
					{
						position = ((Component)val).transform.position;
					}
					if (InCone(position, origin, forward, maxDist, cosHalf))
					{
						TouchEnemy(((Component)val).transform, position, enemyColor);
					}
				}
			}
		}

		private static void ScanInteractables(Vector3 origin, Vector3 forward, float maxDist, float cosHalf)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			try
			{
				num = LayerManager.MASK_MAPPER_DATA_OBJECT;
				if (LayerManager.LAYER_INTERACTION >= 0)
				{
					num |= 1 << LayerManager.LAYER_INTERACTION;
				}
				try
				{
					num |= LayerManager.MASK_MAPPEROBJECT;
				}
				catch
				{
				}
			}
			catch
			{
				num = -1;
			}
			if (num == 0)
			{
				num = -1;
			}
			Collider[] array;
			try
			{
				array = Il2CppArrayBase<Collider>.op_Implicit((Il2CppArrayBase<Collider>)(object)Physics.OverlapSphere(origin, maxDist, num, (QueryTriggerInteraction)2));
			}
			catch
			{
				return;
			}
			if (array == null)
			{
				return;
			}
			s_seenRoots.Clear();
			foreach (Collider val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)FindEnemy(val) != (Object)null) && TryResolveInteract(val, out var root, out var kind))
				{
					int instanceID = ((Object)root).GetInstanceID();
					if (s_seenRoots.Add(instanceID) && InCone(root.position, origin, forward, maxDist, cosHalf, requireWave: false))
					{
						TouchInteractable(root, root.position, ColorForKind(kind, s_scanLocalHolder));
					}
				}
			}
		}

		private static Color ColorEnemy(bool localHolder)
		{
			//IL_0016: 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_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Hikaria.MapperTracker.Features.MapperTracker.MapperTrackerSettings settings = Hikaria.MapperTracker.Features.MapperTracker.Settings;
			if (!localHolder)
			{
				return SColorExtensions.ToUnityColor(settings.TeammateEnemyColor);
			}
			return SColorExtensions.ToUnityColor(settings.EnemyColor);
		}

		private static Color ColorForKind(ItemKind kind, bool localHolder)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: 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)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			Hikaria.MapperTracker.Features.MapperTracker.MapperTrackerSettings settings = Hikaria.MapperTracker.Features.MapperTracker.Settings;
			Color c = (Color)((!localHolder) ? (kind switch
			{
				ItemKind.Terminal => SColorExtensions.ToUnityColor(settings.TeammateTerminalColor), 
				ItemKind.Locker => SColorExtensions.ToUnityColor(settings.TeammateLockerColor), 
				ItemKind.Booster => SColorExtensions.ToUnityColor(settings.TeammateBoosterColor), 
				_ => SColorExtensions.ToUnityColor(settings.TeammateSwitchColor), 
			}) : (kind switch
			{
				ItemKind.Terminal => SColorExtensions.ToUnityColor(settings.TerminalColor), 
				ItemKind.Locker => SColorExtensions.ToUnityColor(settings.LockerColor), 
				ItemKind.Booster => SColorExtensions.ToUnityColor(settings.BoosterColor), 
				_ => SColorExtensions.ToUnityColor(settings.InteractionColor), 
			}));
			return Dim(c);
		}

		private static Color Dim(Color c)
		{
			//IL_0002: 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)
			c.a = Mathf.Clamp(c.a * 0.12f, 0.04f, 0.12f);
			c.r *= 0.55f;
			c.g *= 0.55f;
			c.b *= 0.55f;
			return c;
		}

		private static bool InCone(Vector3 pos, Vector3 origin, Vector3 forward, float maxDist, float cosHalf, bool requireWave = true)
		{
			//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_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pos - origin;
			float magnitude = ((Vector3)(ref val)).magnitude;
			if (magnitude < 0.15f || magnitude > maxDist)
			{
				return false;
			}
			if (Vector3.Dot(forward, val / magnitude) < cosHalf)
			{
				return false;
			}
			if (!requireWave)
			{
				return true;
			}
			return PassedByWaveFront(pos);
		}

		private static bool PassedByWaveFront(Vector3 pos)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!s_waveGateEnabled || !s_waveActive)
			{
				return true;
			}
			float num = (Time.unscaledTime - s_waveStart) / s_waveDuration;
			if (num >= 1f)
			{
				s_waveActive = false;
				return true;
			}
			float num2 = 1f - (1f - num) * (1f - num);
			float num3 = s_waveDistance * num2;
			Vector3 val = pos - s_waveOrigin;
			val.y = 0f;
			float num4 = Vector3.Dot(val, s_waveForward);
			if (num4 < -0.75f || num4 > num3 + 0.75f)
			{
				return false;
			}
			Vector3 val2 = val - s_waveForward * num4;
			float num5 = Mathf.Lerp(1.25f, Mathf.Max(3f, num3 * 0.65f), num2);
			return ((Vector3)(ref val2)).magnitude <= num5;
		}

		private static float WaveGlow(LiveEntry entry, float now)
		{
			float num = Mathf.Max(0.01f, s_swipeSpeed);
			float effectiveSwipePhase = EffectiveSwipePhase;
			if (entry.IsEnemy)
			{
				if (!s_activeSources.Contains(entry.SourceOwner) && entry.FadeStartedAt <= 0f && entry.RevealStartedAt <= 0f)
				{
					return 0f;
				}
				float num2 = DistanceCoord01(entry);
				float time = Time.time;
				if (entry.RevealStartedAt > 0f)
				{
					float num3 = time - entry.RevealStartedAt;
					float enemyRevealTotalSeconds = EnemyRevealTotalSeconds;
					if (num3 >= enemyRevealTotalSeconds)
					{
						if (effectiveSwipePhase + 0.0001f < num2)
						{
							entry.RevealStartedAt = 0f;
						}
						return 0f;
					}
					float num4 = Mathf.SmoothStep(0f, 1f, Mathf.Clamp01(num3 / 0.12f));
					float num5 = Mathf.Max(0f, num3 - 0.12f);
					float num6 = Mathf.Clamp01(1f - num5 / 1.15f);
					num6 *= num6;
					return num4 * num6;
				}
				if (effectiveSwipePhase + 0.0001f < num2)
				{
					return 0f;
				}
				entry.RevealStartedAt = time;
				return 0f;
			}
			float num7 = FovSwipeCoord01(entry);
			float num8 = ((effectiveSwipePhase >= num7) ? ((effectiveSwipePhase - num7) / num) : ((effectiveSwipePhase + (1f - num7)) / num));
			float num9 = Mathf.Clamp01(1f - num8 / 1.15f);
			num9 *= num9;
			return Mathf.Lerp(0.22f, 1f, num9);
		}

		private static float DistanceCoord01(LiveEntry entry)
		{
			//IL_0012: 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)
			float num = Mathf.Max(1f, entry.GlowMaxDist);
			return Mathf.Clamp01(Vector3.Distance(entry.LastPos, entry.GlowOrigin) / num);
		}

		private static float FovSwipeCoord01(LiveEntry entry)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: 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_0078: 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)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//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_0058: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = entry.LastPos - entry.GlowOrigin;
			if (((Vector3)(ref val)).sqrMagnitude < 0.0001f)
			{
				return 0.5f;
			}
			float num = Mathf.Max(1f, entry.GlowFov) * 0.5f;
			float num2 = ((!entry.GlowAxisX) ? Vector3.SignedAngle(entry.GlowForward, Vector3.ProjectOnPlane(val, entry.GlowRight), entry.GlowRight) : Vector3.SignedAngle(entry.GlowForward, Vector3.ProjectOnPlane(val, entry.GlowUp), entry.GlowUp));
			return Mathf.Clamp01((num2 / num + 1f) * 0.5f);
		}

		private static void ApplyGlow(LiveEntry entry, float now)
		{
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			if (entry.ShortGlitch)
			{
				ApplyShortCircuitGlitch(entry);
				return;
			}
			float num2;
			if (entry.FadeStartedAt > 0f && entry.FadeDuration > 0.01f)
			{
				float num = Mathf.Clamp01((Time.unscaledTime - entry.FadeStartedAt) / entry.FadeDuration);
				num2 = entry.FadeStartIntensity * (1f - num);
				num2 *= num2;
			}
			else
			{
				num2 = WaveGlow(entry, now);
				if (entry.IsEnemy && (!(entry.RevealStartedAt > 0f) || !(Time.time - entry.RevealStartedAt < EnemyRevealTotalSeconds)))
				{
					float num3 = entry.ExpiresAt - Time.unscaledTime;
					if (num3 < 1f && s_activeSources.Contains(entry.SourceOwner))
					{
						float num4 = 1f - Mathf.Clamp01(num3 / 1f);
						num2 *= 1f - num4;
					}
				}
			}
			if (num2 > 0.02f)
			{
				entry.HasBeenRevealed = true;
			}
			entry.LastGlowIntensity = num2;
			bool flag = num2 > 0.01f;
			Color baseColor = entry.BaseColor;
			baseColor.a *= num2;
			if (entry.IsMarker)
			{
				if ((Object)(object)entry.MarkerRenderer != (Object)null)
				{
					((Renderer)entry.MarkerRenderer).enabled = flag;
				}
				if (flag)
				{
					ApplyMatColor(entry.MarkerMaterial, baseColor);
				}
			}
			else if (entry.IsHitbox && entry.Hitboxes != null)
			{
				for (int i = 0; i < entry.Hitboxes.Count; i++)
				{
					HitboxLink hitboxLink = entry.Hitboxes[i];
					if (hitboxLink?.Renderers == null)
					{
						continue;
					}
					for (int j = 0; j < hitboxLink.Renderers.Count; j++)
					{
						Renderer val = hitboxLink.Renderers[j];
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						val.enabled = flag;
						if (flag)
						{
							Material material;
							try
							{
								material = val.material;
							}
							catch
							{
								continue;
							}
							if (!((Object)(object)material == (Object)null))
							{
								ApplyMatColor(material, baseColor);
							}
						}
					}
				}
			}
			else
			{
				if (entry.MeshRenderers == null)
				{
					return;
				}
				for (int k = 0; k < entry.MeshRenderers.Count; k++)
				{
					Renderer val2 = entry.MeshRenderers[k];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					val2.enabled = flag;
					if (flag)
					{
						Material material2;
						try
						{
							material2 = val2.material;
						}
						catch
						{
							continue;
						}
						if (!((Object)(object)material2 == (Object)null))
						{
							ApplyMatColor(material2, baseColor);
						}
					}
				}
			}
		}

		private static void ApplyShortCircuitGlitch(LiveEntry entry)
		{
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			float unscaledTime = Time.unscaledTime;
			float num = ((entry.ShortGlitchStartAt > 0f) ? entry.ShortGlitchStartAt : (entry.ShortGlitchEndAt - BatteryScreenUI.DepleteGlitchDuration));
			float shortGlitchEndAt = entry.ShortGlitchEndAt;
			if (BatteryScreenUI.IsDepleteGlitchFinished(num) || unscaledTime >= shortGlitchEndAt)
			{
				entry.ShortGlitch = false;
				entry.LastGlowIntensity = 0f;
				entry.ExpiresAt = unscaledTime;
				HideEntryRenderers(entry);
				return;
			}
			bool flag = BatteryScreenUI.IsDepleteGlitchBitOn(num);
			entry.LastGlowIntensity = (flag ? 1f : 0f);
			int num2 = 0;
			try
			{
				num2 = (((Object)(object)entry.Root != (Object)null) ? ((Object)entry.Root).GetInstanceID() : 0);
			}
			catch
			{
				num2 = 0;
			}
			int num3 = Mathf.FloorToInt((unscaledTime - num) / Mathf.Max(0.01f, BatteryScreenUI.DepleteGlitchBitSeconds));
			if (entry.IsHitbox && entry.Hitboxes != null)
			{
				for (int i = 0; i < entry.Hitboxes.Count; i++)
				{
					HitboxLink hitboxLink = entry.Hitboxes[i];
					if (hitboxLink?.Renderers == null)
					{
						continue;
					}
					bool flag2 = flag && BatteryScreenUI.IsDepleteGlitchBitOnForPart(num, i);
					try
					{
						if ((Object)(object)hitboxLink.Visual != (Object)null)
						{
							((Component)hitboxLink.Visual).gameObject.SetActive(flag2);
						}
					}
					catch
					{
					}
					Color color = s_tvBars[Mathf.Abs(num2 + i * 17 + num3 * 3) % s_tvBars.Length];
					color.a = (flag2 ? 0.28f : 0f);
					for (int j = 0; j < hitboxLink.Renderers.Count; j++)
					{
						Renderer val = hitboxLink.Renderers[j];
						if ((Object)(object)val == (Object)null)
						{
							continue;
						}
						val.enabled = flag2;
						if (!flag2)
						{
							continue;
						}
						Material val2 = null;
						try
						{
							val2 = val.sharedMaterial;
						}
						catch
						{
							val2 = null;
						}
						if ((Object)(object)val2 == (Object)null)
						{
							try
							{
								val2 = val.material;
							}
							catch
							{
								continue;
							}
						}
						if (!((Object)(object)val2 == (Object)null))
						{
							ApplyMatColor(val2, color);
						}
					}
				}
			}
			else
			{
				if (entry.MeshRenderers == null)
				{
					return;
				}
				for (int k = 0; k < entry.MeshRenderers.Count; k++)
				{
					Renderer val3 = entry.MeshRenderers[k];
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					bool flag3 = flag && BatteryScreenUI.IsDepleteGlitchBitOnForPart(num, k);
					Color color2 = s_tvBars[Mathf.Abs(num2 + k + num3) % s_tvBars.Length];
					color2.a = (flag3 ? 0.28f : 0f);
					val3.enabled = flag3;
					if (flag3)
					{
						Material val4 = null;
						try
						{
							val4 = val3.sharedMaterial;
						}
						catch
						{
							val4 = null;
						}
						if (!((Object)(object)val4 == (Object)null))
						{
							ApplyMatColor(val4, color2);
						}
					}
				}
			}
		}

		private static void HideEntryRenderers(LiveEntry entry)
		{
			if (entry.IsHitbox && entry.Hitboxes != null)
			{
				for (int i = 0; i < entry.Hitboxes.Count; i++)
				{
					HitboxLink hitboxLink = entry.Hitboxes[i];
					if (hitboxLink?.Renderers == null)
					{
						continue;
					}
					for (int j = 0; j < hitboxLink.Renderers.Count; j++)
					{
						if