using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using MonitorLabels;
using MonitorLabels.BaseClasses;
using MonitorLabels.Components;
using MonitorLabels.Components.Tools;
using MonitorLabels.Structs;
using MonitorLabels.Utils;
using MonitorLabels.Utils.ModUtils;
using MonitorLabels.VanillaImprovements;
using Monitor_Labels_Continued;
using Monitor_Labels_Continued.BepInEx;
using Monitor_Labels_Continued.Integrations;
using Monitor_Labels_Continued.ModCompat;
using Monitor_Labels_Continued.Utils;
using Monitor_Labels_Continued.Utils.ExtensionMethods;
using Steamworks;
using Steamworks.Data;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Monitor_Labels_Continued")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("Lethal Company Plugin")]
[assembly: AssemblyTitle("Monitor_Labels_Continued")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.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 MonitorLabels
{
	public static class AIMapLabelManager
	{
		public static readonly Dictionary<Type, CustomLabelData> CustomAINames = new Dictionary<Type, CustomLabelData>();

		public static bool TryAddNewAI(Type type, CustomLabelData labelData)
		{
			return CustomAINames.TryAdd(type, labelData);
		}

		public static bool TryAddNewAI(Type type, string label, bool showLabel = true)
		{
			return CustomAINames.TryAdd(type, new CustomLabelData(label, showLabel));
		}

		public static void SetAI(Type type, CustomLabelData customLabelData)
		{
			CustomAINames[type] = customLabelData;
		}

		public static void SetAI(Type type, string label, bool showLabel = true)
		{
			SetAI(type, new CustomLabelData(label, showLabel));
		}

		public static void RemoveAI(Type type)
		{
			CustomAINames.Remove(type);
		}

		public static void AddLabelToAI(EnemyAI enemyAI, Transform mapDotParent, bool checkDisabledObjectsForMapDot)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			bool showLabel;
			string aILabel = GetAILabel(enemyAI, out showLabel);
			if (!showLabel)
			{
				return;
			}
			Transform mapDot = MapLabelUtil.GetMapDot(mapDotParent, checkDisabledObjectsForMapDot);
			if (mapDot == null)
			{
				MonitorLabelsContinued.Logger.LogInfo((object)("Child MapDot cannot be found for enemy: " + ((Object)((Component)enemyAI).gameObject).name));
				return;
			}
			if (enemyAI is SandSpiderAI)
			{
				Vector3 localScale = mapDot.localScale;
				float num = Mathf.Max(new float[3] { localScale.x, localScale.y, localScale.z });
				mapDot.localScale = new Vector3(num, num, num);
			}
			TMP_Text obj = MapLabelUtil.AddLabelObject(((Component)mapDot).gameObject, BepInExConfig.EnemyLabelOffset.Value);
			((Graphic)obj).color = BepInExConfig.EnemyLabelColour.Value;
			obj.text = aILabel;
		}

		public static void UpdateAILabel(EnemyAI enemyAI)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			Transform mapDot = MapLabelUtil.GetMapDot(((Component)enemyAI).transform);
			if (mapDot == null)
			{
				return;
			}
			MapLabelUtil.GetRadarLabel(mapDot, out var label);
			if (label != null)
			{
				if (!BepInExConfig.ShowLabelOnDeadEnemies.Value)
				{
					Object.Destroy((Object)(object)((Component)label).gameObject);
				}
				else
				{
					((Graphic)label).color = BepInExConfig.DeadEnemyLabelColour.Value;
				}
			}
		}

		private static string GetAILabel(EnemyAI enemyAI, out bool showLabel)
		{
			showLabel = true;
			if (!(enemyAI is BaboonBirdAI))
			{
				if (!(enemyAI is BlobAI))
				{
					if (!(enemyAI is CentipedeAI))
					{
						if (!(enemyAI is CrawlerAI))
						{
							if (!(enemyAI is RedLocustBees) && !(enemyAI is DocileLocustBeesAI))
							{
								if (!(enemyAI is DoublewingAI))
								{
									if (!(enemyAI is DressGirlAI))
									{
										if (!(enemyAI is FlowermanAI))
										{
											if (!(enemyAI is ForestGiantAI))
											{
												if (!(enemyAI is HoarderBugAI))
												{
													if (!(enemyAI is JesterAI))
													{
														if (!(enemyAI is LassoManAI))
														{
															if (!(enemyAI is MaskedPlayerEnemy))
															{
																if (!(enemyAI is MouthDogAI))
																{
																	if (!(enemyAI is NutcrackerEnemyAI))
																	{
																		if (!(enemyAI is PufferAI))
																		{
																			if (!(enemyAI is SandSpiderAI))
																			{
																				if (!(enemyAI is SandWormAI))
																				{
																					if (!(enemyAI is SpringManAI))
																					{
																						if (!(enemyAI is TestEnemy))
																						{
																							if (!(enemyAI is ButlerEnemyAI))
																							{
																								if (!(enemyAI is RadMechAI))
																								{
																									if (!(enemyAI is FlowerSnakeEnemy))
																									{
																										if (!(enemyAI is BushWolfEnemy))
																										{
																											CaveDwellerAI val = (CaveDwellerAI)(object)((enemyAI is CaveDwellerAI) ? enemyAI : null);
																											if (val == null)
																											{
																												if (enemyAI is ClaySurgeonAI)
																												{
																													return BepInExConfig.ClaySurgeonLabel.Value;
																												}
																												return GetUnknownAILabel(enemyAI, out showLabel);
																											}
																											if (!ManeaterUtil.HasTransformed(val))
																											{
																												return BepInExConfig.BabyManeaterLabel.Value;
																											}
																											return BepInExConfig.ManeaterLabel.Value;
																										}
																										return BepInExConfig.BushWolfLabel.Value;
																									}
																									if (BepInExConfig.HideLabelOnSomeEnemies.Value)
																									{
																										showLabel = false;
																									}
																									return BepInExConfig.FlowerSnakeLabel.Value;
																								}
																								return BepInExConfig.RadMechLabel.Value;
																							}
																							return BepInExConfig.ButlerLabel.Value;
																						}
																						return "Obunga";
																					}
																					return BepInExConfig.CoilHeadLabel.Value;
																				}
																				if (BepInExConfig.HideLabelOnSomeEnemies.Value)
																				{
																					showLabel = false;
																				}
																				return BepInExConfig.SandWormLabel.Value;
																			}
																			return BepInExConfig.SpiderLabel.Value;
																		}
																		return BepInExConfig.SporeLizardLabel.Value;
																	}
																	return BepInExConfig.NutCrackerLabel.Value;
																}
																return BepInExConfig.DogLabel.Value;
															}
															return BepInExConfig.MaskedLabel.Value;
														}
														return "Lasso";
													}
													return BepInExConfig.JesterLabel.Value;
												}
												return BepInExConfig.HoarderBugLabel.Value;
											}
											return BepInExConfig.ForestGiantLabel.Value;
										}
										return BepInExConfig.BrackenLabel.Value;
									}
									showLabel = false;
									return "Girl";
								}
								if (BepInExConfig.HideLabelOnSomeEnemies.Value)
								{
									showLabel = false;
								}
								return BepInExConfig.ManticoilLabel.Value;
							}
							showLabel = false;
							return "Bees";
						}
						return BepInExConfig.CrawlerLabel.Value;
					}
					return BepInExConfig.CentipedeLabel.Value;
				}
				return BepInExConfig.BlobLabel.Value;
			}
			return BepInExConfig.BaboonHawkLabel.Value;
		}

		private static string GetUnknownAILabel(EnemyAI enemyAISubclassInstance, out bool showLabel)
		{
			foreach (KeyValuePair<Type, CustomLabelData> customAIName in CustomAINames)
			{
				if (customAIName.Key.IsInstanceOfType(enemyAISubclassInstance))
				{
					showLabel = customAIName.Value.ShowLabel;
					return customAIName.Value.Label;
				}
			}
			showLabel = true;
			string value = BepInExConfig.UnknownLabel.Value;
			if (!value.Equals(string.Empty))
			{
				return value;
			}
			return MapLabelUtil.RemoveCloneFromString(((Object)((Component)enemyAISubclassInstance).gameObject).name).InsertSpaceBeforeCapitals();
		}
	}
	internal static class ObjectLabelManager
	{
		internal static void TryAddLabelToScrap(GrabbableObject item)
		{
			Transform radarIcon = item.radarIcon;
			if (!((Object)(object)radarIcon == (Object)null))
			{
				AddLabelToScrap(item, ((Component)radarIcon).gameObject);
			}
		}

		internal static void UpdateScrapLabel(GrabbableObject item)
		{
			UpdateItemSlotLabel(item, null, null);
		}

		internal static void UpdateItemSlotLabel(GrabbableObject item, GrabbableObject firstToolInItemSlots, GrabbableObject firstToolInUseInItemSlots)
		{
			Transform radarIcon = item.radarIcon;
			if ((Object)(object)radarIcon == (Object)null && !item.itemProperties.isScrap && BepInExConfig.ShowIconOnTools.Value)
			{
				ContinuouslyUpdateToolLabel component = ((Component)item).GetComponent<ContinuouslyUpdateToolLabel>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				ToolIconSpawner.SpawnIcon(item);
				radarIcon = item.radarIcon;
				if ((Object)(object)radarIcon != (Object)null && BepInExConfig.ShowLabelOnTools.Value)
				{
					TryAddLabelToScrap(item);
				}
			}
			if ((Object)(object)radarIcon == (Object)null)
			{
				return;
			}
			ContinuouslyUpdateToolLabel component2 = ((Component)item).GetComponent<ContinuouslyUpdateToolLabel>();
			if (!((Object)(object)component2 != (Object)null) || !component2.IsUpdating)
			{
				MapLabelUtil.GetRadarLabel(radarIcon, out var label);
				if (label != null)
				{
					SetScrapLabel(item, label, firstToolInItemSlots, firstToolInUseInItemSlots);
				}
			}
		}

		internal static void SetScrapLabel(GrabbableObject item, TMP_Text radarLabel, GrabbableObject firstToolInItemSlots = null, GrabbableObject firstToolInUseInItemSlots = null)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			radarLabel.text = GetScrapLabelString(item, out var labelColour, firstToolInItemSlots, firstToolInUseInItemSlots);
			((Graphic)radarLabel).color = labelColour;
		}

		private static void AddLabelToScrap(GrabbableObject item, GameObject radarParent)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			bool isScrap = item.itemProperties.isScrap;
			TMP_Text val = MapLabelUtil.AddLabelObject(radarParent, isScrap ? BepInExConfig.ScrapLabelOffset.Value : BepInExConfig.ToolLabelOffset.Value, continuouslyUpdateRotationAndOffset: false);
			if (isScrap)
			{
				val.fontSize *= BepInExConfig.ScrapLabelScaleFactor.Value;
			}
			else
			{
				val.fontSize = BepInExConfig.ToolLabelFontSize.Value;
			}
			SetScrapLabel(item, val);
			if (item.itemProperties.requiresBattery && BepInExConfig.ShowBatteryChargeOnLabel.Value)
			{
				((Component)item).gameObject.AddComponent<ContinuouslyUpdateToolLabel>().Initialize(item, val);
			}
		}

		private static string GetScrapLabelString(GrabbableObject item, out Color labelColour, GrabbableObject firstToolInItemSlots, GrabbableObject firstToolInUseInItemSlots)
		{
			//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)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null)
			{
				labelColour = Color.white;
				return string.Empty;
			}
			bool flag = !item.itemProperties.isScrap;
			int scrapValue = item.scrapValue;
			if (item.isHeld)
			{
				if (flag && (Object)(object)item.playerHeldBy != (Object)null)
				{
					labelColour = BepInExConfig.CarriedToolLabelColour.Value;
					GrabbableObject currentlyHeldObjectServer = item.playerHeldBy.currentlyHeldObjectServer;
					bool flag2 = (Object)(object)currentlyHeldObjectServer != (Object)null && !currentlyHeldObjectServer.itemProperties.isScrap;
					if (item.isPocketed && BepInExConfig.HideToolLabelIfPocketed.Value)
					{
						if (!item.isBeingUsed || !BepInExConfig.ShowToolIfInUseAndNoOtherToolHeld.Value || flag2)
						{
							return string.Empty;
						}
						if (BepInExConfig.OnlyShow1PocketedLabel.Value)
						{
							GrabbableObject val = ((IEnumerable<GrabbableObject>)item.playerHeldBy.ItemSlots).FirstOrDefault((Func<GrabbableObject, bool>)((GrabbableObject grabbableObject) => (Object)(object)grabbableObject != (Object)null && grabbableObject.isBeingUsed));
							if ((Object)(object)val == (Object)null && (Object)(object)item.playerHeldBy.ItemOnlySlot != (Object)null && item.playerHeldBy.ItemOnlySlot.isBeingUsed)
							{
								val = item.playerHeldBy.ItemOnlySlot;
							}
							if ((Object)(object)item != (Object)(object)val)
							{
								return string.Empty;
							}
						}
					}
					else if (item.isPocketed && BepInExConfig.OnlyShow1PocketedLabel.Value)
					{
						if (flag2 && !BepInExConfig.HideToolLabelIfInHand.Value)
						{
							return string.Empty;
						}
						if (BepInExConfig.ShowToolIfInUseAndNoOtherToolHeld.Value)
						{
							if ((Object)(object)firstToolInUseInItemSlots != (Object)null)
							{
								if ((Object)(object)firstToolInUseInItemSlots != (Object)(object)item)
								{
									return string.Empty;
								}
							}
							else if ((Object)(object)firstToolInItemSlots != (Object)(object)item)
							{
								return string.Empty;
							}
						}
						else if ((Object)(object)item != (Object)(object)firstToolInItemSlots)
						{
							return string.Empty;
						}
					}
					else if (!item.isPocketed && BepInExConfig.HideToolLabelIfInHand.Value)
					{
						return string.Empty;
					}
				}
				else if (flag)
				{
					labelColour = BepInExConfig.CarriedToolLabelColour.Value;
					if (BepInExConfig.HideToolLabelIfInHand.Value)
					{
						return string.Empty;
					}
				}
				else
				{
					labelColour = BepInExConfig.CarriedScrapLabelColour.Value;
					if (BepInExConfig.HideScrapLabelIfCarried.Value)
					{
						return string.Empty;
					}
				}
			}
			else if (item.isInShipRoom)
			{
				if (flag)
				{
					labelColour = BepInExConfig.InShipToolLabelColour.Value;
					if (BepInExConfig.HideToolLabelIfOnShip.Value)
					{
						return string.Empty;
					}
				}
				else
				{
					labelColour = BepInExConfig.InShipScrapLabelColour.Value;
					if (BepInExConfig.HideScrapLabelIfOnShip.Value)
					{
						return string.Empty;
					}
				}
			}
			else if (flag)
			{
				labelColour = BepInExConfig.ToolLabelColour.Value;
			}
			else
			{
				labelColour = ((scrapValue >= BepInExConfig.HighValueScrapThreshold.Value) ? BepInExConfig.HighValueScrapLabelColour.Value : BepInExConfig.ScrapLabelColour.Value);
			}
			if (TryGetCustomLabel(item, out var label))
			{
				return label;
			}
			return GetFormattedScrapLabel(item, scrapValue, flag);
		}

		private static bool TryGetCustomLabel(GrabbableObject item, out string label)
		{
			label = string.Empty;
			if (BepInExConfig.HideScrapLabelOnNutcracker.Value && item is ShotgunItem && item.isHeldByEnemy)
			{
				return true;
			}
			return false;
		}

		private static string GetFormattedScrapLabel(GrabbableObject item, int scrapValue, bool isTool)
		{
			string scrapName = GetScrapName(item);
			if (isTool)
			{
				string arg = string.Empty;
				if (item.itemProperties.requiresBattery && BepInExConfig.ShowBatteryChargeOnLabel.Value && item.insertedBattery != null)
				{
					float num = (item.insertedBattery.empty ? 0f : item.insertedBattery.charge);
					arg = string.Format(BepInExConfig.ToolBatteryStringFormat.Value, num);
				}
				return string.Format(BepInExConfig.ToolLabelStringFormat.Value, scrapName, arg);
			}
			return string.Format(BepInExConfig.ScrapLabelStringFormat.Value, scrapName, scrapValue);
		}

		private static string GetScrapName(GrabbableObject item)
		{
			Item itemProperties = item.itemProperties;
			if (Object.op_Implicit((Object)(object)itemProperties) && !string.IsNullOrEmpty(itemProperties.itemName))
			{
				return itemProperties.itemName;
			}
			ScanNodeProperties componentInChildren = ((Component)item).GetComponentInChildren<ScanNodeProperties>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				return componentInChildren.headerText;
			}
			return MapLabelUtil.RemoveCloneFromString(((Object)((Component)item).gameObject).name).InsertSpaceBeforeCapitals();
		}
	}
	internal static class RadarTargetLabelManager
	{
		internal static void UpdateLabel(Transform radarTargetTransform)
		{
			if (!((Object)(object)radarTargetTransform == (Object)null))
			{
				int index;
				bool isCurrentRadarTarget;
				TransformAndName matchingRadarTarget = RadarTargetUtils.GetMatchingRadarTarget(radarTargetTransform, out index, out isCurrentRadarTarget);
				if (matchingRadarTarget == null || (Object)(object)matchingRadarTarget.transform == (Object)null)
				{
					MonitorLabelsContinued.Logger.LogInfo((object)"Tried to update an invalid transform!\nUpdating all radar targets to make sure everything is correct!");
					UpdateLabels();
				}
				else
				{
					AddTargetLabel(matchingRadarTarget, index, isCurrentRadarTarget);
				}
			}
		}

		internal static void UpdateLabels(int radarTargetIndex = -1)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.mapScreen == (Object)null)
			{
				return;
			}
			int num = ((radarTargetIndex != -1) ? radarTargetIndex : StartOfRound.Instance.mapScreen.targetTransformIndex);
			for (int i = 0; i < StartOfRound.Instance.mapScreen.radarTargets.Count; i++)
			{
				bool isCurrentTarget = num == i;
				TransformAndName val = StartOfRound.Instance.mapScreen.radarTargets[i];
				if (val != null && (Object)(object)val.transform != (Object)null)
				{
					AddTargetLabel(val, i, isCurrentTarget);
				}
			}
		}

		internal static void AddTargetLabel(TransformAndName transformAndName, int index, bool isCurrentTarget)
		{
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB component = ((Component)transformAndName.transform).gameObject.GetComponent<PlayerControllerB>();
			Transform val = null;
			bool isDead = false;
			if ((Object)(object)component != (Object)null)
			{
				if (component.isPlayerDead)
				{
					isDead = true;
					if ((Object)(object)component.redirectToEnemy != (Object)null)
					{
						val = FindRadarDotOfPlayer(((Component)component.redirectToEnemy).transform);
					}
					else
					{
						if (!((Object)(object)component.deadBody != (Object)null))
						{
							return;
						}
						val = MapLabelUtil.GetMapDot(((Component)component.deadBody).transform);
					}
				}
				else
				{
					val = FindRadarDotOfPlayer(((Component)component).transform);
				}
			}
			else
			{
				val = MapLabelUtil.GetRadarBoosterMapDot(transformAndName.transform);
			}
			if ((Object)(object)val == (Object)null)
			{
				MonitorLabelsContinued.Logger.LogInfo((object)("Cannot find radar icon for " + transformAndName.name));
				return;
			}
			TMP_Text label;
			Transform radarLabel = MapLabelUtil.GetRadarLabel(val, out label);
			if ((Object)(object)label == (Object)null)
			{
				if ((Object)(object)radarLabel != (Object)null)
				{
					MonitorLabelsContinued.Logger.LogInfo((object)"The LabelObject exists but the TMP_Text component does not, this should never happen!\nDestroying the object and reinstantiating it...");
					Object.Destroy((Object)(object)((Component)radarLabel).gameObject);
				}
				label = MapLabelUtil.AddLabelObject(((Component)val).gameObject, BepInExConfig.RadarTargetLabelOffset.Value);
			}
			label.text = GetLabelString(transformAndName, index, isCurrentTarget, isDead, transformAndName.isNonPlayer, component, out var labelColour);
			((Graphic)label).color = labelColour;
		}

		private static string GetLabelString(TransformAndName targetName, int index, bool isTarget, bool isDead, bool isRadarBooster, PlayerControllerB playerControllerB, out Color labelColour)
		{
			//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)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			if (isDead)
			{
				labelColour = BepInExConfig.DeadPlayerLabelColour.Value;
				if (BepInExConfig.ForceDeadPlayerLabel.Value)
				{
					return GetRadarTargetNameString(targetName, index, isDead: true);
				}
				if (BepInExConfig.HideDeadPlayerLabels.Value || BepInExConfig.HidePlayerLabels.Value)
				{
					return string.Empty;
				}
			}
			else
			{
				if (!isRadarBooster && BepInExConfig.HidePlayerLabels.Value)
				{
					labelColour = Color.white;
					return string.Empty;
				}
				if (isTarget)
				{
					if (isRadarBooster)
					{
						labelColour = BepInExConfig.TargetRadarBoosterLabelColour.Value;
					}
					else if (BepInExConfig.UseColorsToShowPlayerHealth.Value)
					{
						labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: true);
					}
					else
					{
						labelColour = Colors.GetPlayerColor(playerControllerB, isTarget: true);
					}
					if (!BepInExConfig.ShowLabelOnTarget.Value)
					{
						return string.Empty;
					}
				}
				else if (isRadarBooster)
				{
					labelColour = BepInExConfig.RadarBoosterLabelColour.Value;
					if (BepInExConfig.HideRadarBoosterLabels.Value)
					{
						return string.Empty;
					}
				}
				else if (BepInExConfig.UseColorsToShowPlayerHealth.Value)
				{
					labelColour = ColorCalculator.GetColorDependingOnHealth(playerControllerB, isTarget: false);
				}
				else
				{
					labelColour = Colors.GetPlayerColor(playerControllerB, isTarget: false);
				}
			}
			return GetRadarTargetNameString(targetName, index, isDead);
		}

		private static string GetRadarTargetNameString(TransformAndName targetTransformAndName, int index, bool isDead = false)
		{
			string text = targetTransformAndName.name;
			if (isDead)
			{
				string value = BepInExConfig.CustomDeadName.Value;
				if (value != string.Empty)
				{
					text = value;
				}
			}
			text = text[..Mathf.Min(text.Length, BepInExConfig.MaximumNameLength.Value)];
			string arg = string.Empty;
			if (!targetTransformAndName.isNonPlayer && !isDead)
			{
				int currentSlotValue;
				int totalValueCarrying = ScrapUtil.GetTotalValueCarrying(((Component)targetTransformAndName.transform).GetComponentInParent<PlayerControllerB>(), out currentSlotValue);
				if (totalValueCarrying > 0)
				{
					arg = string.Format(BepInExConfig.PlayerCarriedScrapValueStringFormat.Value, totalValueCarrying, currentSlotValue);
				}
			}
			return string.Format(BepInExConfig.PlayerLabelStringFormat.Value, text, index, arg);
		}

		private static Transform FindRadarDotOfPlayer(Transform parent)
		{
			Transform val = parent.Find("Misc");
			Transform val2 = val.Find("MapDot");
			if (!((Object)(object)val2 != (Object)null))
			{
				return MapLabelUtil.GetMapDot(val);
			}
			return val2;
		}
	}
}
namespace MonitorLabels.VanillaImprovements
{
	public class DestroyRadarIconOnDestroy : BetterMonoBehaviour
	{
		private GrabbableObject grabbableObject;

		private void Awake()
		{
			grabbableObject = ((Component)this).GetComponent<GrabbableObject>();
		}

		private void OnDestroy()
		{
			if (!((Object)(object)grabbableObject == (Object)null))
			{
				Transform radarIcon = grabbableObject.radarIcon;
				if (!((Object)(object)radarIcon == (Object)null))
				{
					Object.Destroy((Object)(object)((Component)radarIcon).gameObject);
					grabbableObject = null;
				}
			}
		}
	}
}
namespace MonitorLabels.Structs
{
	public struct CustomLabelData
	{
		public string Label;

		public bool ShowLabel;

		public CustomLabelData(string label, bool showLabel = true)
		{
			Label = label;
			ShowLabel = showLabel;
		}
	}
}
namespace MonitorLabels.Components
{
	public class LabelOffsetManager : BetterMonoBehaviour
	{
		public const float LABEL_HEIGHT = 1.15f;

		public Vector2 Offset { get; set; }

		private void Start()
		{
			SetOffset();
		}

		protected void SetOffset()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0022: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = base.transform.parent.position;
			position += MapCameraRotationObserver.MapCameraUp * Offset.y;
			position += MapCameraRotationObserver.MapCameraRight * Offset.x;
			position += Vector3.up * 1.15f;
			base.transform.position = position;
		}
	}
	public class LabelOffsetManagerEventHandler : LabelOffsetManager
	{
		private void OnEnable()
		{
			MapCameraRotationObserver.OnMapCameraRotated += base.SetOffset;
		}

		private void OnDisable()
		{
			MapCameraRotationObserver.OnMapCameraRotated -= base.SetOffset;
		}
	}
	public class LabelOffsetManagerContinuously : LabelOffsetManager
	{
		private void LateUpdate()
		{
			SetOffset();
		}
	}
	public class MapCameraRotationObserver : BetterMonoBehaviour
	{
		public static Vector3 MapCameraUp { get; private set; }

		public static Vector3 MapCameraRight { get; private set; }

		public static Quaternion MapCameraRotation { get; private set; }

		public static event Action OnMapCameraRotated;

		private void LateUpdate()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Quaternion rotation = base.CachedTransform.rotation;
			if (!QuaternionMathUtil.IsApproximate(MapCameraRotation, rotation))
			{
				MapCameraRotated(base.CachedTransform);
			}
		}

		private static void MapCameraRotated(Transform transform)
		{
			//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
			MapCameraUp = transform.up;
			MapCameraRight = transform.right;
			MapCameraRotation = transform.rotation;
			MapCameraRotationObserver.OnMapCameraRotated();
		}

		static MapCameraRotationObserver()
		{
			//IL_0024: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: 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)
			MapCameraRotationObserver.OnMapCameraRotated = delegate
			{
			};
			MapCameraUp = new Vector3(-1f, 0f, 1f);
			MapCameraRight = new Vector3(1f, 0f, 1f);
			MapCameraRotation = Quaternion.Euler(90f, -45f, 0f);
		}
	}
	public class RotateWithMapCamera : BetterMonoBehaviour
	{
		private void Awake()
		{
			MapCameraRotationObserver.OnMapCameraRotated += RotateWithCamera;
		}

		private void RotateWithCamera()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			base.CachedTransform.rotation = MapCameraRotationObserver.MapCameraRotation;
		}

		private void OnDestroy()
		{
			MapCameraRotationObserver.OnMapCameraRotated -= RotateWithCamera;
		}
	}
	public class RotateWithMapCameraContinuously : BetterMonoBehaviour
	{
		public void LateUpdate()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			base.CachedTransform.rotation = MapCameraRotationObserver.MapCameraRotation;
		}
	}
}
namespace MonitorLabels.Components.Tools
{
	internal class ContinuouslyUpdateToolLabel : BetterMonoBehaviour
	{
		private TMP_Text label;

		private GrabbableObject item;

		internal bool IsUpdating { get; private set; }

		internal void Initialize(GrabbableObject grabbableObject, TMP_Text radarLabel)
		{
			item = grabbableObject;
			label = radarLabel;
			((MonoBehaviour)this).StartCoroutine(UpdateLabelRoutine());
		}

		private void UpdateLabel()
		{
			PlayerItemSlotsUtil.GetFirstToolAndFirstToolInUse(item.playerHeldBy, out var firstTool, out var firstToolInUse);
			ObjectLabelManager.SetScrapLabel(item, label, firstTool, firstToolInUse);
		}

		private IEnumerator UpdateLabelRoutine()
		{
			while (true)
			{
				IsUpdating = true;
				while (item.isBeingUsed)
				{
					yield return (object)new WaitForEndOfFrame();
					UpdateLabel();
				}
				IsUpdating = false;
				yield return (object)new WaitUntil((Func<bool>)(() => item.isBeingUsed));
			}
		}
	}
}
namespace MonitorLabels.BaseClasses
{
	public class BetterMonoBehaviour : MonoBehaviour
	{
		private Transform cachedTransform;

		private GameObject cachedGameObject;

		public Transform CachedTransform
		{
			get
			{
				if ((Object)(object)cachedTransform == (Object)null)
				{
					cachedTransform = ((Component)this).transform;
				}
				return cachedTransform;
			}
		}

		public GameObject CachedGameObject
		{
			get
			{
				if (cachedGameObject == null)
				{
					cachedGameObject = ((Component)this).gameObject;
				}
				return cachedGameObject;
			}
		}

		public Transform transform => CachedTransform;

		public GameObject gameObject => CachedGameObject;
	}
}
namespace MonitorLabels.Utils
{
	public static class ManeaterUtil
	{
		public static bool HasTransformed(CaveDwellerAI caveDwellerAI)
		{
			return (double)caveDwellerAI.growthMeter >= 1.0;
		}
	}
	public static class MapLabelUtil
	{
		public const string MAP_DOT_NAME = "MapDot";

		public const string RADAR_BOOSTER_DOT_NAME = "RadarBoosterDot";

		public const string LABEL_OBJECT_NAME = "MapLabel";

		private static readonly Vector3 labelPosition = new Vector3(0f, 0.5f, 0f);

		private static readonly Vector3 labelScale = new Vector3(0.5f, 0.5f, 0.5f);

		public static TMP_Text AddLabelObject(GameObject parent, Vector2 labelOffset, bool continuouslyUpdateRotationAndOffset = true)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001f: 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_0034: 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)
			GameObject val = new GameObject("MapLabel");
			Transform transform = val.transform;
			transform.SetParent(parent.transform, false);
			transform.localPosition = labelPosition;
			transform.rotation = MapCameraRotationObserver.MapCameraRotation;
			transform.localScale = labelScale;
			val.layer = parent.layer;
			val.tag = parent.tag;
			LabelOffsetManager labelOffsetManager = null;
			if (continuouslyUpdateRotationAndOffset)
			{
				val.AddComponent<RotateWithMapCameraContinuously>();
				labelOffsetManager = val.AddComponent<LabelOffsetManagerContinuously>();
			}
			else
			{
				val.AddComponent<RotateWithMapCamera>();
				labelOffsetManager = val.AddComponent<LabelOffsetManagerEventHandler>();
			}
			labelOffsetManager.Offset = labelOffset;
			TextMeshPro obj = val.AddComponent<TextMeshPro>();
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((TMP_Text)obj).autoSizeTextContainer = true;
			((TMP_Text)obj).enableWordWrapping = false;
			((TMP_Text)obj).overflowMode = (TextOverflowModes)0;
			return (TMP_Text)(object)obj;
		}

		public static Transform GetMapDot(Transform parent, bool checkDisabledObjects = false)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			Queue<Transform> queue = new Queue<Transform>();
			foreach (Transform item in parent)
			{
				Transform val = item;
				if (checkDisabledObjects || ((Component)val).gameObject.activeInHierarchy)
				{
					queue.Enqueue(val);
				}
			}
			while (queue.Count > 0)
			{
				Transform val2 = queue.Dequeue();
				if (((Object)((Component)val2).gameObject).name.Contains("MapDot"))
				{
					return val2;
				}
				foreach (Transform item2 in val2)
				{
					Transform val3 = item2;
					if (checkDisabledObjects || ((Component)val3).gameObject.activeInHierarchy)
					{
						queue.Enqueue(val3);
					}
				}
			}
			return null;
		}

		public static Transform GetRadarLabel(Transform radarParent, out TMP_Text label)
		{
			Transform val = radarParent.Find("MapLabel");
			label = (((Object)(object)val != (Object)null) ? ((Component)val).GetComponent<TMP_Text>() : null);
			return val;
		}

		public static Transform GetRadarBoosterMapDot(Transform radarParent)
		{
			return radarParent.Find("RadarBoosterDot");
		}

		public static string RemoveCloneFromString(string name)
		{
			int num = name.IndexOf('(');
			if (num != -1)
			{
				return name.Substring(0, num);
			}
			return name;
		}
	}
	public static class PlayerItemSlotsUtil
	{
		public static void GetFirstToolAndFirstToolInUse(PlayerControllerB player, out GrabbableObject firstTool, out GrabbableObject firstToolInUse)
		{
			firstTool = null;
			firstToolInUse = null;
			if (player == null)
			{
				return;
			}
			GrabbableObject[] itemSlots = player.ItemSlots;
			foreach (GrabbableObject val in itemSlots)
			{
				if (!((Object)(object)val == (Object)null) && !val.itemProperties.isScrap)
				{
					if (firstTool == null)
					{
						firstTool = val;
					}
					if (val.isBeingUsed && firstToolInUse == null)
					{
						firstToolInUse = val;
						return;
					}
				}
			}
			if ((Object)(object)player.ItemOnlySlot != (Object)null && !player.ItemOnlySlot.itemProperties.isScrap)
			{
				if (firstTool == null)
				{
					firstTool = player.ItemOnlySlot;
				}
				if (player.ItemOnlySlot.isBeingUsed && firstToolInUse == null)
				{
					firstToolInUse = player.ItemOnlySlot;
				}
			}
		}

		public static void UpdateLabelsOfItemSlots(PlayerControllerB player)
		{
			if (!BepInExConfig.ShowLabelOnTools.Value)
			{
				return;
			}
			GetFirstToolAndFirstToolInUse(player, out var firstTool, out var firstToolInUse);
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				GrabbableObject val = player.ItemSlots[i];
				if (!((Object)(object)val == (Object)null) && !val.itemProperties.isScrap)
				{
					ObjectLabelManager.UpdateItemSlotLabel(val, firstTool, firstToolInUse);
				}
			}
			if ((Object)(object)player.ItemOnlySlot != (Object)null && !player.ItemOnlySlot.itemProperties.isScrap)
			{
				ObjectLabelManager.UpdateItemSlotLabel(player.ItemOnlySlot, firstTool, firstToolInUse);
			}
		}
	}
	public static class QuaternionMathUtil
	{
		public static bool IsApproximate(Quaternion lhs, Quaternion rhs, float precision = 4E-07f)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return 1f - Mathf.Abs(Quaternion.Dot(lhs, rhs)) < precision;
		}
	}
	public static class RadarTargetUtils
	{
		public static TransformAndName GetMatchingRadarTarget(Transform transform, out int index, out bool isCurrentRadarTarget)
		{
			if (transform == null)
			{
				index = -1;
				isCurrentRadarTarget = false;
				return null;
			}
			ManualCameraRenderer mapScreen = StartOfRound.Instance.mapScreen;
			int targetTransformIndex = mapScreen.targetTransformIndex;
			for (index = 0; index < mapScreen.radarTargets.Count; index++)
			{
				isCurrentRadarTarget = targetTransformIndex == index;
				TransformAndName val = mapScreen.radarTargets[index];
				if (val != null)
				{
					Transform transform2 = val.transform;
					if (transform == transform2)
					{
						return val;
					}
				}
			}
			isCurrentRadarTarget = false;
			return null;
		}
	}
	public static class ScrapUtil
	{
		public static int GetTotalValueCarrying(PlayerControllerB player, out int currentSlotValue)
		{
			currentSlotValue = 0;
			if (player == null)
			{
				return 0;
			}
			GrabbableObject val = null;
			if (player.currentItemSlot >= 0 && player.currentItemSlot < player.ItemSlots.Length)
			{
				val = player.ItemSlots[player.currentItemSlot];
			}
			else if (player.currentItemSlot == 50)
			{
				val = player.ItemOnlySlot;
			}
			if ((Object)(object)val != (Object)null && val.itemProperties.isScrap)
			{
				currentSlotValue = val.scrapValue;
			}
			int num = player.ItemSlots.Sum((GrabbableObject item) => (!((Object)(object)item == (Object)null) && item.itemProperties.isScrap) ? item.scrapValue : 0);
			if ((Object)(object)player.ItemOnlySlot != (Object)null && player.ItemOnlySlot.itemProperties.isScrap)
			{
				num += player.ItemOnlySlot.scrapValue;
			}
			return num;
		}
	}
	public static class ToolIconSpawner
	{
		private const int mapRadarLayer = 14;

		private static readonly GameObject iconPrefab;

		static ToolIconSpawner()
		{
			AssetBundleUtil.TryLoadAsset<GameObject>("terminalmarker.lem", "Assets/Mods/TerminalMarker/ItemMarker.prefab", out iconPrefab);
			AssetBundleUtil.TryLoadAsset<Material>("terminalmarker.lem", "Assets/Mods/TerminalMarker/MarkerMaterial.mat", out Material asset);
			iconPrefab.GetComponent<Renderer>().sharedMaterial = asset;
		}

		public static void SpawnIcon(GrabbableObject grabbableObject)
		{
			GameObject val = Object.Instantiate<GameObject>(iconPrefab, RoundManager.Instance.mapPropsContainer.transform);
			((Object)val).name = "Tool Marker (" + grabbableObject.itemProperties.itemName + ")";
			val.layer = 14;
			grabbableObject.radarIcon = val.transform;
		}
	}
}
namespace MonitorLabels.Utils.ModUtils
{
	public static class AssetBundleUtil
	{
		private static readonly string assemblyDirectory;

		private static readonly Dictionary<string, AssetBundle> loadedAssetBundles;

		static AssetBundleUtil()
		{
			loadedAssetBundles = new Dictionary<string, AssetBundle>();
			assemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		}

		public static bool TryLoadAsset<TAssetType>(string bundleName, string assetPath, out TAssetType asset) where TAssetType : Object
		{
			if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle))
			{
				asset = default(TAssetType);
				return false;
			}
			asset = assetBundle.LoadAsset<TAssetType>(assetPath);
			return true;
		}

		public static bool TryLoadAllAssets<TAssetType>(string bundleName, out TAssetType[] assets) where TAssetType : Object
		{
			if (!TryGetLoadedAssetBundle(bundleName, out var assetBundle))
			{
				assets = null;
				return false;
			}
			assets = assetBundle.LoadAllAssets<TAssetType>();
			return assets.Length != 0;
		}

		public static bool TryLoadAssetBundle(string bundleName, out AssetBundle assetBundle)
		{
			assetBundle = AssetBundle.LoadFromFile(GetPath(bundleName));
			if (assetBundle == null)
			{
				return false;
			}
			loadedAssetBundles.Add(bundleName, assetBundle);
			return true;
		}

		public static bool TryUnloadAssetBundle(string bundleName, bool unloadAllLoadedObjects)
		{
			if (loadedAssetBundles.Remove(bundleName, out var value))
			{
				value.Unload(unloadAllLoadedObjects);
				return true;
			}
			return false;
		}

		public static void UnloadAllAssetBundles(bool unloadAllLoadedObjects)
		{
			AssetBundle.UnloadAllAssetBundles(unloadAllLoadedObjects);
		}

		private static bool TryGetLoadedAssetBundle(string bundleName, out AssetBundle assetBundle)
		{
			if (loadedAssetBundles.TryGetValue(bundleName, out var value))
			{
				assetBundle = value;
				return true;
			}
			return TryLoadAssetBundle(bundleName, out assetBundle);
		}

		private static string GetPath(string path)
		{
			return Path.Combine(assemblyDirectory, path);
		}
	}
}
namespace Monitor_Labels_Continued
{
	[BepInProcess("Lethal Company.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("LethalCompany.Lego.MonitorLabelContinued", "Monitor Label Continued", "3.1.5")]
	public class MonitorLabelsContinued : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		public static MonitorLabelsContinued Instance;

		private void Awake()
		{
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			Logger.LogInfo((object)"Monitor Label Continued v3.1.5 Loading...");
			ConfigMigration.Migrate();
			((BaseUnityPlugin)this).Config.Reload();
			InitBepInEx.Init(((BaseUnityPlugin)this).Config);
			InitModIntegrations.Init("LethalCompany.Lego.MonitorLabelContinued", "3.1.5");
			InitModCompat.Init();
			Logger.LogInfo((object)"Monitor Label Continued v3.1.5 plugin fully loaded.");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "Monitor_Labels_Continued";

		public const string PLUGIN_NAME = "Lethal Company Plugin";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace Monitor_Labels_Continued.Utils
{
	public static class ColorCalculator
	{
		public const int FULL_HEALTH = 100;

		public const int HALF_HEALTH = 50;

		public const int CRITICAL_HEALTH = 10;

		public static Color GetColorDependingOnHealth(PlayerControllerB playerController, bool isTarget)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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_0024: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			Color value = BepInExConfig.PlayerFullHealthColour.Value;
			Color value2 = BepInExConfig.PlayerHalfHealthColour.Value;
			Color value3 = BepInExConfig.PlayerCriticalHealthColour.Value;
			if (playerController == null)
			{
				return value;
			}
			if (playerController.health == 100)
			{
				return Colors.GetPlayerColor(playerController, isTarget);
			}
			float num = 0f;
			if (playerController.health >= 50)
			{
				num = Mathf.InverseLerp(50f, 100f, (float)playerController.health);
				return Color.Lerp(value2, value, num);
			}
			num = Mathf.InverseLerp(10f, 50f, (float)playerController.health);
			return Color.Lerp(value3, value2, num);
		}
	}
	public static class ConfigMigration
	{
		private static float lastMigrationClickTime;

		public static void Migrate()
		{
			try
			{
				string configPath = Paths.ConfigPath;
				string text = Path.Combine(configPath, "DannyVD.mods.LethalCompany.MonitorLabels.cfg");
				string text2 = Path.Combine(configPath, "LethalComapny.Lego.MonitorLabelContinued.cfg");
				string text3 = Path.Combine(configPath, "LethalCompany.Lego.MonitorLabelContinued.cfg");
				if (!File.Exists(text3))
				{
					if (File.Exists(text2))
					{
						File.Move(text2, text3);
						MonitorLabelsContinued.Logger.LogInfo((object)"Successfully migrated and renamed misspelled configuration file (v3.0.0 -> v3.0.1)");
					}
					else if (File.Exists(text))
					{
						File.Copy(text, text3);
						MonitorLabelsContinued.Logger.LogInfo((object)"Successfully copied and migrated settings from the original MonitorLabels mod");
					}
				}
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogWarning((object)("Failed to run configuration migration: " + ex.Message));
			}
		}

		public static void RequestMigration()
		{
			try
			{
				string configPath = Paths.ConfigPath;
				string text = Path.Combine(configPath, "DannyVD.mods.LethalCompany.MonitorLabels.cfg");
				string destFileName = Path.Combine(configPath, "LethalCompany.Lego.MonitorLabelContinued.cfg");
				if (File.Exists(text))
				{
					float realtimeSinceStartup = Time.realtimeSinceStartup;
					if (realtimeSinceStartup - lastMigrationClickTime > 3f)
					{
						lastMigrationClickTime = realtimeSinceStartup;
						return;
					}
					lastMigrationClickTime = 0f;
					File.Copy(text, destFileName, overwrite: true);
					((BaseUnityPlugin)MonitorLabelsContinued.Instance).Config.Reload();
					BepInExConfig.ReadConfig();
					MonitorLabelsContinued.Logger.LogInfo((object)"Successfully migrated and applied settings from the original MonitorLabels mod!");
				}
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogWarning((object)("Failed to run configuration migration request: " + ex.Message));
			}
		}
	}
	internal class Constants
	{
		public const string CUSTOM_PLAYER_COLOR_METADATA_KEY = "MonitorLabelsContinued_CustomPlayerLabelColor";
	}
	internal static class PluginInfos
	{
		public const string PLUGIN_NAME = "Monitor Label Continued";

		public const string PLUGIN_GUID = "LethalCompany.Lego.MonitorLabelContinued";

		public const string PLUGIN_VERSION = "3.1.5";
	}
	public static class SteamIDs
	{
		public const ulong ORIGINAL_DEV_ID = 76561198166372065uL;

		public const ulong CONTINUED_DEV_ID = 76561198368204860uL;
	}
	public static class Colors
	{
		public static readonly Color OriginalDevColor = new Color(0.52f, 0f, 0.56f);

		public static readonly Color ContinuedDevColor = new Color(0.81f, 0.34f, 1f);

		public static readonly string ContinuedDevColorHex = "#" + ColorUtility.ToHtmlStringRGB(ContinuedDevColor).ToLower();

		public static Color GetPlayerColor(PlayerControllerB player, bool isTarget)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: 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_00a2: 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_00cc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return Color.white;
			}
			if (player.playerSteamId == 76561198166372065L)
			{
				return OriginalDevColor;
			}
			if (player.playerSteamId == 76561198368204860L)
			{
				if ((Object)(object)GameNetworkManager.Instance != (Object)null && GameNetworkManager.Instance.currentLobby.HasValue)
				{
					try
					{
						Lobby value = GameNetworkManager.Instance.currentLobby.Value;
						SteamId val = SteamId.op_Implicit(player.playerSteamId);
						Friend val2 = default(Friend);
						((Friend)(ref val2))..ctor(val);
						string memberData = ((Lobby)(ref value)).GetMemberData(val2, "MonitorLabelsContinued_CustomPlayerLabelColor");
						Color result = default(Color);
						if (!string.IsNullOrEmpty(memberData) && ColorUtility.TryParseHtmlString(memberData, ref result))
						{
							return result;
						}
					}
					catch
					{
					}
				}
				return ContinuedDevColor;
			}
			if (!isTarget)
			{
				return BepInExConfig.DefaultPlayerLabelColour.Value;
			}
			return BepInExConfig.TargetPlayerLabelColour.Value;
		}
	}
}
namespace Monitor_Labels_Continued.Utils.ExtensionMethods
{
	public static class StringExtensions
	{
		public static string InsertSpaceBeforeCapitals(this string text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return text;
			}
			string text2 = text.ToUpper();
			string text3 = text;
			if (text.Length == 1)
			{
				return text3;
			}
			for (int num = text.Length - 1; num >= 1; num--)
			{
				if (text[num] == text2[num])
				{
					text3 = text3.Insert(num, " ");
				}
			}
			return text3;
		}
	}
}
namespace Monitor_Labels_Continued.Integrations
{
	internal class InitModIntegrations
	{
		public static void Init(string pluginGuid, string pluginVersion)
		{
			if (Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility"))
			{
				LobbyCompatModIntegration.Register(pluginGuid, pluginVersion);
			}
			else
			{
				MonitorLabelsContinued.Logger.LogInfo((object)"LobbyCompatibility not detected. Skipping compatibility registration.");
			}
			if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
			{
				LethalConfigIntegration.Init();
			}
			else
			{
				MonitorLabelsContinued.Logger.LogInfo((object)"LethalConfig not detected. Skipping custom menu setup.");
			}
		}
	}
	internal class LethalConfigIntegration
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static GenericButtonHandler <0>__ApplyChanges;

			public static GenericButtonHandler <1>__RequestMigration;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//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_00aa: Expected O, but got Unknown
			//IL_005d: 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_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//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_00e3: Expected O, but got Unknown
			try
			{
				LethalConfigManager.SetModDescription("No desc yet");
				string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "icon.png");
				if (File.Exists(path))
				{
					byte[] array = File.ReadAllBytes(path);
					Texture2D val = new Texture2D(2, 2);
					if (ImageConversion.LoadImage(val, array))
					{
						LethalConfigManager.SetModIcon(Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f)));
					}
				}
				object obj = <>O.<0>__ApplyChanges;
				if (obj == null)
				{
					GenericButtonHandler val2 = ApplyChanges;
					<>O.<0>__ApplyChanges = val2;
					obj = (object)val2;
				}
				LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("RELOAD CONFIG", "Apply all config file changes", "Reloads the config file for Monitor Label Continued\nThis way the settings will take immediate effect.", "Apply", (GenericButtonHandler)obj));
				object obj2 = <>O.<1>__RequestMigration;
				if (obj2 == null)
				{
					GenericButtonHandler val3 = ConfigMigration.RequestMigration;
					<>O.<1>__RequestMigration = val3;
					obj2 = (object)val3;
				}
				LethalConfigManager.AddConfigItem((BaseConfigItem)new GenericButtonConfigItem("RELOAD CONFIG", "Import settings from original mod (3s-Double click)", "Imports your settings from the original MonitorLabels mod (if found). Warning: This will overwrite your current settings! [[ require a 3s-Double click to execute ]]", "Migrate", (GenericButtonHandler)obj2));
				MonitorLabelsContinued.Logger.LogInfo((object)"Successfully registered configs with LethalConfig!");
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register with LethalConfig: " + ex.Message));
			}
		}

		private static void ApplyChanges()
		{
			BepInExConfig.ReadConfig();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void RegisterDevColor(ConfigEntry<string> devColorConfig)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			try
			{
				LethalConfigManager.AddConfigItem((BaseConfigItem)new HexColorInputFieldConfigItem(devColorConfig, false));
				MonitorLabelsContinued.Logger.LogInfo((object)"Registered DevRadarColor with LethalConfig!");
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register DevRadarColor with LethalConfig: " + ex.Message));
			}
		}
	}
	public static class LobbyCompatModIntegration
	{
		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Register(string pluginGuid, string pluginVersion)
		{
			try
			{
				PluginHelper.RegisterPlugin(pluginGuid, new Version(pluginVersion), (CompatibilityLevel)0, (VersionStrictness)0);
				MonitorLabelsContinued.Logger.LogInfo((object)"Successfully registered with LobbyCompatibility.");
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogWarning((object)("Failed to register with LobbyCompatibility: " + ex.Message));
			}
		}
	}
}
namespace Monitor_Labels_Continued.ModCompat
{
	internal class InitModCompat
	{
		public static void Init()
		{
		}
	}
}
namespace Monitor_Labels_Continued.BepInEx
{
	internal class BepInExConfig
	{
		public static ConfigEntry<LogLevel> LoggingLevel;

		public static ConfigEntry<bool> ForceDeadPlayerLabel;

		public static ConfigEntry<int> MaximumNameLength;

		public static ConfigEntry<bool> ShowLabelOnTarget;

		public static ConfigEntry<string> CustomDeadName;

		public static ConfigEntry<bool> HidePlayerLabels;

		public static ConfigEntry<bool> HideDeadPlayerLabels;

		public static ConfigEntry<bool> HideRadarBoosterLabels;

		public static ConfigEntry<bool> UseColorsToShowPlayerHealth;

		public static ConfigEntry<bool> ShowIconOnTools;

		public static ConfigEntry<bool> ShowLabelOnTools;

		public static ConfigEntry<bool> ShowBatteryChargeOnLabel;

		public static ConfigEntry<float> ToolLabelFontSize;

		public static ConfigEntry<bool> HideToolLabelIfOnShip;

		public static ConfigEntry<bool> HideToolLabelIfInHand;

		public static ConfigEntry<bool> HideToolLabelIfPocketed;

		public static ConfigEntry<bool> OnlyShow1PocketedLabel;

		public static ConfigEntry<bool> ShowToolIfInUseAndNoOtherToolHeld;

		public static ConfigEntry<bool> ShowLabelOnScrap;

		public static ConfigEntry<float> ScrapLabelScaleFactor;

		public static ConfigEntry<bool> HideScrapLabelIfOnShip;

		public static ConfigEntry<bool> HideScrapLabelIfCarried;

		public static ConfigEntry<int> HighValueScrapThreshold;

		public static ConfigEntry<bool> HideScrapLabelOnNutcracker;

		public static ConfigEntry<bool> ShowLabelOnEnemies;

		public static ConfigEntry<bool> ShowLabelOnDeadEnemies;

		public static ConfigEntry<bool> HideLabelOnSomeEnemies;

		public static ConfigEntry<string> UnknownLabel;

		public static ConfigEntry<string> BaboonHawkLabel;

		public static ConfigEntry<string> BlobLabel;

		public static ConfigEntry<string> CentipedeLabel;

		public static ConfigEntry<string> CrawlerLabel;

		public static ConfigEntry<string> ManticoilLabel;

		public static ConfigEntry<string> BrackenLabel;

		public static ConfigEntry<string> ForestGiantLabel;

		public static ConfigEntry<string> HoarderBugLabel;

		public static ConfigEntry<string> JesterLabel;

		public static ConfigEntry<string> MaskedLabel;

		public static ConfigEntry<string> DogLabel;

		public static ConfigEntry<string> NutCrackerLabel;

		public static ConfigEntry<string> SporeLizardLabel;

		public static ConfigEntry<string> SpiderLabel;

		public static ConfigEntry<string> SandWormLabel;

		public static ConfigEntry<string> CoilHeadLabel;

		public static ConfigEntry<string> ButlerLabel;

		public static ConfigEntry<string> RadMechLabel;

		public static ConfigEntry<string> FlowerSnakeLabel;

		public static ConfigEntry<string> ManeaterLabel;

		public static ConfigEntry<string> BabyManeaterLabel;

		public static ConfigEntry<string> ClaySurgeonLabel;

		public static ConfigEntry<string> BushWolfLabel;

		public static ConfigEntry<Color> DeadPlayerLabelColour;

		public static ConfigEntry<Color> TargetPlayerLabelColour;

		public static ConfigEntry<Color> DefaultPlayerLabelColour;

		public static ConfigEntry<Color> PlayerFullHealthColour;

		public static ConfigEntry<Color> PlayerHalfHealthColour;

		public static ConfigEntry<Color> PlayerCriticalHealthColour;

		public static ConfigEntry<Color> TargetRadarBoosterLabelColour;

		public static ConfigEntry<Color> RadarBoosterLabelColour;

		public static ConfigEntry<Color> EnemyLabelColour;

		public static ConfigEntry<Color> DeadEnemyLabelColour;

		public static ConfigEntry<Color> ToolLabelColour;

		public static ConfigEntry<Color> CarriedToolLabelColour;

		public static ConfigEntry<Color> InShipToolLabelColour;

		public static ConfigEntry<Color> ScrapLabelColour;

		public static ConfigEntry<Color> HighValueScrapLabelColour;

		public static ConfigEntry<Color> CarriedScrapLabelColour;

		public static ConfigEntry<Color> InShipScrapLabelColour;

		public static ConfigEntry<Vector2> RadarTargetLabelOffset;

		public static ConfigEntry<Vector2> EnemyLabelOffset;

		public static ConfigEntry<Vector2> ToolLabelOffset;

		public static ConfigEntry<Vector2> ScrapLabelOffset;

		public static ConfigEntry<bool> RemoveDetonatedMineLabel;

		public static ConfigEntry<string> PlayerLabelStringFormat;

		public static ConfigEntry<string> PlayerCarriedScrapValueStringFormat;

		public static ConfigEntry<string> ScrapLabelStringFormat;

		public static ConfigEntry<string> ToolLabelStringFormat;

		public static ConfigEntry<string> ToolBatteryStringFormat;

		public static ConfigFile config;

		internal static void Init(ConfigFile configFile)
		{
			config = configFile;
		}

		public static void ReadConfig()
		{
			//IL_06a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Unknown result type (might be due to invalid IL or missing references)
			//IL_0750: Unknown result type (might be due to invalid IL or missing references)
			//IL_0793: Unknown result type (might be due to invalid IL or missing references)
			//IL_07c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_081c: Unknown result type (might be due to invalid IL or missing references)
			//IL_083f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0876: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0907: Unknown result type (might be due to invalid IL or missing references)
			//IL_093e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0961: Unknown result type (might be due to invalid IL or missing references)
			//IL_0984: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_09d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5b: Unknown result type (might be due to invalid IL or missing references)
			LoggingLevel = config.Bind<LogLevel>("0. General", "logLevel", (LogLevel)7, "What should be logged?\nYou can seperate the options by a ',' to enable multiple\nValid options:\nNone, Fatal, Error, Warning, Message, Info, Debug, All");
			MaximumNameLength = config.Bind<int>("1.1 RadarTarget/Player", "maximumNameLength", 5, "The maximum length of the name that will be shown on the terminal");
			ShowLabelOnTarget = config.Bind<bool>("1.1 RadarTarget/Player", "showLabelOnTarget", true, "Should the currently targeted player also show a label");
			ForceDeadPlayerLabel = config.Bind<bool>("1.1 RadarTarget/Player", "forceDeadPlayerLabel", true, "Should the label of a dead player always be visible?\nThis is to show dead labels if 'hideNormalLabels' is disabled");
			CustomDeadName = config.Bind<string>("1.1 RadarTarget/Player", "customDeadLabel", string.Empty, "A custom label to show if someone is dead, leave empty to use their name instead");
			HidePlayerLabels = config.Bind<bool>("1.1 RadarTarget/Player", "hidePlayerLabels", false, "Don't use any player labels except for 'forceDeadPlayerLabel'");
			HideDeadPlayerLabels = config.Bind<bool>("1.1 RadarTarget/Player", "hideDeadPlayerLabels", false, "Don't use labels for dead players");
			UseColorsToShowPlayerHealth = config.Bind<bool>("1.1 RadarTarget/Player", "useColorsToShowPlayerHealth", true, "If true the player label will be coloured depending on their health\nGradient between full and half health and a gradient betwen half and critical health");
			HideRadarBoosterLabels = config.Bind<bool>("1.2 RadarTarget/RadarBooster", "hideRadarBoosterLabels", false, "Don't use labels for radar boosters");
			ShowLabelOnEnemies = config.Bind<bool>("2.1 Enemies", "showLabelOnEnemies", true, "Should enemies have labels?");
			ShowLabelOnDeadEnemies = config.Bind<bool>("2.1 Enemies", "showLabelOnDeadEnemies", false, "Should the label stay on a dead enemy?");
			HideLabelOnSomeEnemies = config.Bind<bool>("2.1 Enemies", "hideLabelOnSomeEnemies", true, "Don't show a label for the following enemies:\nManticoil\nWorm");
			UnknownLabel = config.Bind<string>("2.2 Enemy Labels", "unknownLabel", string.Empty, "The label of an unidentified enemy, leave empty to use the name");
			BaboonHawkLabel = config.Bind<string>("2.2 Enemy Labels", "baboonHawkLabel", "Hawk", "The label of the BaboonBird enemy");
			BlobLabel = config.Bind<string>("2.2 Enemy Labels", "blobLabel", "Blob", "The label of the Blob enemy");
			CentipedeLabel = config.Bind<string>("2.2 Enemy Labels", "snareFleaLabel", "Snare", "The label of the Centipede (Snare Flea) enemy");
			CrawlerLabel = config.Bind<string>("2.2 Enemy Labels", "crawlerLabel", "Half", "The label of the Crawler (Thumper) enemy");
			ManticoilLabel = config.Bind<string>("2.2 Enemy Labels", "manticoilLabel", "Bird", "The label of the Doublewing (Manticoil) enemy");
			BrackenLabel = config.Bind<string>("2.2 Enemy Labels", "brackenLabel", "Bracken", "The label of the FlowerMan (Bracken) enemy");
			ForestGiantLabel = config.Bind<string>("2.2 Enemy Labels", "forestGiantLabel", "Giant", "The label of the ForestGiant enemy");
			HoarderBugLabel = config.Bind<string>("2.2 Enemy Labels", "hoarderBugLabel", "Bug", "The label of the HoarderBug enemy");
			JesterLabel = config.Bind<string>("2.2 Enemy Labels", "jesterLabel", "Jester", "The label of the Jester enemy");
			MaskedLabel = config.Bind<string>("2.2 Enemy Labels", "maskedPlayerLabel", "X", "The label of the MaskedPlayer enemy");
			DogLabel = config.Bind<string>("2.2 Enemy Labels", "mouthDogLabel", "Dog", "The label of the MouthDog enemy");
			NutCrackerLabel = config.Bind<string>("2.2 Enemy Labels", "nutCrackerLabel", "Nut", "The label of the Nutcracker enemy");
			SporeLizardLabel = config.Bind<string>("2.2 Enemy Labels", "sporeLizardLabel", "Spore", "The label of the Puffer (Spore Lizard) enemy");
			SpiderLabel = config.Bind<string>("2.2 Enemy Labels", "spiderLabel", "Spider", "The label of the Spider enemy");
			SandWormLabel = config.Bind<string>("2.2 Enemy Labels", "sandWormLabel", string.Empty, "The label of the SandWorm enemy");
			CoilHeadLabel = config.Bind<string>("2.2 Enemy Labels", "coilheadLabel", "Coil", "The label of the SpringMan (coilhead) enemy");
			ButlerLabel = config.Bind<string>("2.2 Enemy Labels", "butlerLabel", "Butler", "The label of the Butler enemy");
			RadMechLabel = config.Bind<string>("2.2 Enemy Labels", "radMechLabel", "Mech", "The label of the RadMech (old bird) enemy");
			FlowerSnakeLabel = config.Bind<string>("2.2 Enemy Labels", "flowerSnakeLabel", "Snake", "The label of the FlowerSnake (Tulip Snake) enemy");
			BushWolfLabel = config.Bind<string>("2.2 Enemy Labels", "bushWolfLabel", "Fox", "The label of the BushWolf (Kidnapper Fox) enemy");
			ManeaterLabel = config.Bind<string>("2.2 Enemy Labels", "maneaterLabel", "Maneater", "The label of the CaveDweller (Maneater) enemy");
			BabyManeaterLabel = config.Bind<string>("2.2 Enemy Labels", "babyManeaterLabel", "Baby", "The label of the CaveDweller (Maneater) enemy when in 'baby' state");
			ClaySurgeonLabel = config.Bind<string>("2.2 Enemy Labels", "claySurgeonLabel", "Barber", "The label of the ClaySurgeon (Barber) enemy");
			ShowIconOnTools = config.Bind<bool>("3.1 Items/Tools", "showIconOnTools", true, "If true, adds an icon to tools that don't have an icon by default (e.g. Keys, flashlights, shovels)");
			ShowLabelOnTools = config.Bind<bool>("3.1 Items/Tools", "showLabelOnTools", true, "If true, adds a label to tools (e.g. Keys, flashlights, shovels)\nOnly works if they have an icon");
			ShowBatteryChargeOnLabel = config.Bind<bool>("3.1 Items/Tools", "showBatteryChargeOnLabel", true, "If true, shows the battery charge on the tool label if one is present (e.g. Flashlights)");
			ToolLabelFontSize = config.Bind<float>("3.1 Items/Tools", "toolLabelFontSize", 600f, "The size of the font of a tool label");
			HideToolLabelIfOnShip = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfOnShip", true, "Hide the label if the tool is on the ship");
			HideToolLabelIfInHand = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfInHand", false, "Hide the label if the tool is being carried in the players hand");
			HideToolLabelIfPocketed = config.Bind<bool>("3.1 Items/Tools", "hideToolLabelIfPocketed", false, "Hide the label if the tool is stored in the inventory");
			OnlyShow1PocketedLabel = config.Bind<bool>("3.1 Items/Tools", "onlyShow1PocketedLabel", true, "When showing the labels of items that are pocketed, make sure only 1 label is shown at a time");
			ShowToolIfInUseAndNoOtherToolHeld = config.Bind<bool>("3.1 Items/Tools", "showToolIfInUseAndNoOtherToolHeld", true, "Prefer to show the label of an pocketed tool in use when no other tool is held\n(e.g. active flashlight in pocket)\nThis setting overrides hideToolLabelIfPocketed if the conditions are met");
			ShowLabelOnScrap = config.Bind<bool>("3.2 Items/Scrap", "showLabelOnScrap", true, "Should scrap also have a label?");
			ScrapLabelScaleFactor = config.Bind<float>("3.2 Items/Scrap", "scrapLabelScaleFactor", 3.5f, "The factor to increase the label text size with");
			HideScrapLabelIfOnShip = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelOnShip", true, "Hide the label if the scrap is on the ship");
			HideScrapLabelIfCarried = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelIfCarried", true, "Hide the label if the scrap is being carried");
			HighValueScrapThreshold = config.Bind<int>("3.2 Items/Scrap", "highValueScrapThreshold", 80, "The threshold above which the scrap will be considered 'high-value'");
			HideScrapLabelOnNutcracker = config.Bind<bool>("3.2 Items/Scrap", "hideScrapLabelOnNutcracker", true, "Hide the shotgun label if it is held by the nutcracker");
			DeadPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "deadPlayerLabelColour", Color.red, "The colour of a label of a player that is dead");
			TargetPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "targetPlayerLabelColour", Color.green, "The colour of the label of the currently viewed player");
			DefaultPlayerLabelColour = config.Bind<Color>("4.1 Colours/Players", "defaultPlayerLabelColour", Color.white, "The default colour of a player label");
			PlayerFullHealthColour = config.Bind<Color>("4.1 Colours/Players", "playerFullHealthColour", Color.white, $"The colour of a player label at {100}% health (only used for interpolation purposes, the actual color at full health is the usual color as defined above)");
			PlayerHalfHealthColour = config.Bind<Color>("4.1 Colours/Players", "playerHalfHealthColour", new Color(1f, 0.31f, 0.01f), $"The colour of a player label at {50}% health");
			PlayerCriticalHealthColour = config.Bind<Color>("4.1 Colours/Players", "playerCriticalHealthColour", new Color(0.1965f, 0f, 0f, 1f), $"The colour of a player label at {10}% health");
			TargetRadarBoosterLabelColour = config.Bind<Color>("4.2 Colours/RadarBooster", "targetRadarBoosterLabelColour", Color.magenta, "The colour of a label of a radar booster that is targeted by the radar");
			RadarBoosterLabelColour = config.Bind<Color>("4.2 Colours/RadarBooster", "radarBoosterLabelColour", Color.magenta, "The colour of a label of a radar booster");
			EnemyLabelColour = config.Bind<Color>("4.3 Colours/Enemies", "enemyLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of an enemy");
			DeadEnemyLabelColour = config.Bind<Color>("4.3 Colours/Enemies", "deadEnemyLabelColour", Color.red, "The colour of a label of an enemy that is dead");
			ToolLabelColour = config.Bind<Color>("4.4 Colours/Tools", "toolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of the label of tools");
			CarriedToolLabelColour = config.Bind<Color>("4.4 Colours/Tools", "carriedToolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of a tool that is being carried by a player");
			InShipToolLabelColour = config.Bind<Color>("4.4 Colours/Tools", "inShipToolLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of a tool that is stored in the ship");
			ScrapLabelColour = config.Bind<Color>("4.5 Colours/Scrap", "scrapLabelColour", Color.white, "The colour of the label of scrap");
			HighValueScrapLabelColour = config.Bind<Color>("4.5 Colours/Scrap", "highValueScrapLabelColour", new Color(1f, 0.5f, 0.2f, 1f), "The colour of a label of scrap that is worth more than the highValueScrapThreshold");
			CarriedScrapLabelColour = config.Bind<Color>("4.5 Colours/Scrap", "carriedScrapLabelColour", Color.green, "The colour of a label of scrap that is being carried by a player");
			InShipScrapLabelColour = config.Bind<Color>("4.5 Colours/Scrap", "inShipScrapLabelColour", Color.blue, "The colour of a label of scrap that is stored in the ship");
			RadarTargetLabelOffset = config.Bind<Vector2>("5.1 Label Offsets/RadarTarget", "radarTargetLabelOffset", Vector2.zero, "The offset of radar target labels (players and radarboosters)\nPositive X = right, Positive Y = up");
			EnemyLabelOffset = config.Bind<Vector2>("5.2 Label Offsets/Enemies", "enemyLabelOffset", Vector2.down * 0.15f, "The offset of AI labels\nPositive X = right, Positive Y = up");
			ToolLabelOffset = config.Bind<Vector2>("5.3 Label Offsets/Items", "toolLabelOffset", Vector2.up * 1.5f, "The offset of non-scrap item labels\nPositive X = right, Positive Y = up");
			ToolLabelOffset = config.Bind<Vector2>("5.3 Label Offsets/Items", "toolLabelOffset", Vector2.up * 1.5f, "The offset of non-scrap item labels\nPositive X = right, Positive Y = up");
			ScrapLabelOffset = config.Bind<Vector2>("5.3 Label Offsets/Items", "scrapLabelOffset", Vector2.up * 1.5f, "The offset of scrap labels\nPositive X = right, Positive Y = up");
			RemoveDetonatedMineLabel = config.Bind<bool>("9. Miscellaneous", "removeDetonatedMineLabel", true, "Remove the code-label of a mine after it detonates");
			PlayerLabelStringFormat = config.Bind<string>("99. Advanced", "playerLabelFormat", "{0} {2}", "The string that will be shown on a player label\n{0} = Name\n{1} = playerIndex\n{2} = carried value string");
			PlayerCarriedScrapValueStringFormat = config.Bind<string>("99. Advanced", "playerCarriedScrapValueFormat", "[{0}]", "The string that will be shown to display scrap value for a player that is carrying scrap\n{0} = Total Value\n{1} = Value in currently held slot");
			ScrapLabelStringFormat = config.Bind<string>("99. Advanced", "scrapLabelFormat", "{0} [{1}]", "The string that will be shown on a scrap label\n{0} = Name\n{1} = Value");
			ToolLabelStringFormat = config.Bind<string>("99. Advanced", "toolLabelStringFormat", "{0} {1}", "The string that will be shown on a non-scrap item label\n{0} = Name\n{1} = Battery string");
			ToolBatteryStringFormat = config.Bind<string>("99. Advanced", "toolBatteryStringFormat", "[{0:P0}]", "The string that will be shown for the battery charge\n{0} = Battery charge");
		}
	}
	internal class BepInExPatchs
	{
		public static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			Harmony val = new Harmony("LethalCompany.Lego.MonitorLabelContinued");
			MonitorLabelsContinued.Logger.LogInfo((object)"Attempting to patch with Harmony!");
			try
			{
				val.PatchAll(typeof(HarmonyPatches));
				MonitorLabelsContinued.Logger.LogInfo((object)"Patching success!");
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogInfo((object)("Failed to patch: " + ex));
			}
		}
	}
	internal class HarmonyPatches
	{
		[HarmonyPatch(typeof(ManualCameraRenderer), "Awake")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void ManualCameraRendererAwakePatch(ManualCameraRenderer __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.Awake patch run");
			NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
			if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening)
			{
				RadarTargetLabelManager.UpdateLabels();
				if (__instance.mapCamera != null)
				{
					((Component)__instance.mapCamera).gameObject.AddComponent<MapCameraRotationObserver>();
				}
			}
		}

		[HarmonyPatch(typeof(ManualCameraRenderer), "AddTransformAsTargetToRadar")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void ManualCameraRendererAddTransformAsTargetToRadarPatch()
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.AddTransformAsTargetToRadar patch run");
			RadarTargetLabelManager.UpdateLabels();
		}

		[HarmonyPatch(typeof(ManualCameraRenderer), "updateMapTarget")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void ManualCameraRendererUpdateMapTargetPatch(int setRadarTargetIndex, bool calledFromRPC = true)
		{
			if (calledFromRPC)
			{
				MonitorLabelsContinued.Logger.LogInfo((object)"ManualCameraRenderer.updateMapTarget patch run");
				RadarTargetLabelManager.UpdateLabels(setRadarTargetIndex);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SendNewPlayerValuesClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBSendNewPlayerValuesClientRpcPatch(PlayerControllerB __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SendNewPlayerValuesClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabels();
		}

		[HarmonyPatch(typeof(StartOfRound), "SetShipReadyToLand")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void StartOfRoundSetShipReadyToLandPatch()
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"StartOfRound.SetShipReadyToLand patch run");
			RadarTargetLabelManager.UpdateLabels();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayerClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBDamagePlayerClientRpcPatch(PlayerControllerB __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.DamagePlayerClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayerClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBKillPlayerClientRpcPatch(PlayerControllerB __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.KillPlayerClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
		}

		[HarmonyPatch(typeof(EnemyAI), "Start")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void EnemyAIStartPatch(EnemyAI __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"EnemyAI.Start patch run");
			if (BepInExConfig.ShowLabelOnEnemies.Value)
			{
				AIMapLabelManager.AddLabelToAI(__instance, ((Component)__instance).transform, checkDisabledObjectsForMapDot: false);
			}
		}

		[HarmonyPatch(typeof(CaveDwellerAI), "becomeAdultAnimation")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void becomeAdultAnimationPatch(CaveDwellerAI __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"CaveDwellerAI.becomeAdultAnimation patch run");
			if (BepInExConfig.ShowLabelOnEnemies.Value)
			{
				__instance.growthMeter = 1f;
				AIMapLabelManager.AddLabelToAI((EnemyAI)(object)__instance, __instance.adultContainer.transform, checkDisabledObjectsForMapDot: true);
			}
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "Start")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void MaskedPlayerEnemyStartPatch(MaskedPlayerEnemy __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"MaskedPlayerEnemy.Start patch run");
			if (BepInExConfig.ShowLabelOnEnemies.Value)
			{
				AIMapLabelManager.AddLabelToAI((EnemyAI)(object)__instance, ((Component)__instance).transform, checkDisabledObjectsForMapDot: false);
			}
		}

		[HarmonyPatch(typeof(EnemyAI), "KillEnemy")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void EnemyAIKillEnemyPatch(EnemyAI __instance, bool destroy = false)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"EnemyAI.KillEnemy patch run");
			if (!destroy && BepInExConfig.ShowLabelOnEnemies.Value && !((Object)(object)__instance == (Object)null))
			{
				AIMapLabelManager.UpdateAILabel(__instance);
			}
		}

		[HarmonyPatch(typeof(NutcrackerEnemyAI), "GrabGun")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void NutcrackerEnemyAIGrabGunPatch(NutcrackerEnemyAI __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"NutcrackerEnemyAI.GrabGun patch run");
			if (BepInExConfig.ShowLabelOnScrap.Value && !((Object)(object)__instance.gun == (Object)null))
			{
				ObjectLabelManager.UpdateScrapLabel((GrabbableObject)(object)__instance.gun);
			}
		}

		[HarmonyPatch(typeof(NutcrackerEnemyAI), "DropGun")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void NutcrackerEnemyAIDropGunPatch(NutcrackerEnemyAI __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"NutcrackerEnemyAI.DropGun patch run");
			if (BepInExConfig.ShowLabelOnScrap.Value && !((Object)(object)__instance.gun == (Object)null))
			{
				ObjectLabelManager.UpdateScrapLabel((GrabbableObject)(object)__instance.gun);
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "Start")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void GrabbableObjectStartPatch(GrabbableObject __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.Start patch run");
			((Component)__instance).gameObject.AddComponent<DestroyRadarIconOnDestroy>();
			if (!__instance.itemProperties.isScrap)
			{
				if (BepInExConfig.ShowIconOnTools.Value && (Object)(object)__instance.radarIcon == (Object)null)
				{
					ToolIconSpawner.SpawnIcon(__instance);
				}
				if (BepInExConfig.ShowLabelOnTools.Value)
				{
					ObjectLabelManager.TryAddLabelToScrap(__instance);
				}
			}
			else if (BepInExConfig.ShowLabelOnScrap.Value)
			{
				ObjectLabelManager.TryAddLabelToScrap(__instance);
			}
		}

		[HarmonyPatch(typeof(GrabbableObject), "OnBroughtToShip")]
		[HarmonyPrefix]
		[HarmonyPriority(200)]
		private static bool GrabbableObjectOnBroughtToShipPatch(GrabbableObject __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.OnBroughtToShip patch run");
			return __instance.itemProperties.isScrap;
		}

		[HarmonyPatch(typeof(GrabbableObject), "SetScrapValue")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void GrabbableObjectSetScrapValuePatch(GrabbableObject __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.SetScrapValue patch run");
			if (BepInExConfig.ShowLabelOnScrap.Value)
			{
				PlayerControllerB playerHeldBy = __instance.playerHeldBy;
				if ((Object)(object)playerHeldBy != (Object)null)
				{
					RadarTargetLabelManager.UpdateLabel(((Component)playerHeldBy).transform);
					PlayerItemSlotsUtil.GetFirstToolAndFirstToolInUse(playerHeldBy, out var firstTool, out var firstToolInUse);
					ObjectLabelManager.UpdateItemSlotLabel(__instance, firstTool, firstToolInUse);
				}
				else
				{
					ObjectLabelManager.UpdateScrapLabel(__instance);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBSwitchToItemSlotPatch(PlayerControllerB __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SwitchToItemSlot patch run"));
			PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
		}

		[HarmonyPatch(typeof(GrabbableObject), "UseItemOnClient")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void GrabbableObjectUseItemOnClientPatch(GrabbableObject __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.UseItemOnClient patch run");
			PlayerControllerB playerHeldBy = __instance.playerHeldBy;
			if (playerHeldBy != null)
			{
				PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(playerHeldBy);
			}
			else if (!__instance.itemProperties.isScrap && BepInExConfig.ShowLabelOnTools.Value)
			{
				ObjectLabelManager.UpdateScrapLabel(__instance);
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "SetItemInElevator")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBSetItemInElevatorPatch(PlayerControllerB __instance, GrabbableObject gObject)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.SetItemInElevator patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
			if ((Object)(object)gObject == (Object)null)
			{
				return;
			}
			if (gObject.itemProperties.isScrap)
			{
				if (!BepInExConfig.ShowLabelOnScrap.Value)
				{
					return;
				}
			}
			else if (!BepInExConfig.ShowLabelOnTools.Value)
			{
				return;
			}
			ObjectLabelManager.UpdateScrapLabel(gObject);
		}

		[HarmonyPatch(typeof(GrabbableObject), "DiscardItemOnClient")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void GrabbableObjectDiscardItemOnClientPatch(GrabbableObject __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"GrabbableObject.DiscardItemOnClient patch run");
			ObjectLabelManager.UpdateScrapLabel(__instance);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "PlaceObjectClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBPlaceObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.PlaceObjectClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
			PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
			NetworkObject val = default(NetworkObject);
			if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null))
			{
				ObjectLabelManager.UpdateScrapLabel(((Component)val).GetComponent<GrabbableObject>());
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ThrowObjectClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBThrowObjectClientRpcPatch(PlayerControllerB __instance, ref NetworkObjectReference grabbedObject)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.ThrowObjectClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
			PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
			NetworkObject val = default(NetworkObject);
			if (((NetworkObjectReference)(ref grabbedObject)).TryGet(ref val, (NetworkManager)null))
			{
				ObjectLabelManager.UpdateScrapLabel(((Component)val).GetComponent<GrabbableObject>());
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void PlayerControllerBGrabObjectClientRpcPatch(PlayerControllerB __instance, NetworkObjectReference grabbedObject)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			MonitorLabelsContinued.Logger.LogInfo((object)("[" + __instance.playerUsername + "] PlayerControllerB.GrabObjectClientRpc patch run"));
			RadarTargetLabelManager.UpdateLabel(((Component)__instance).transform);
			GrabbableObject componentInChildren = ((Component)NetworkObjectReference.op_Implicit(grabbedObject)).GetComponentInChildren<GrabbableObject>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				return;
			}
			if (componentInChildren.itemProperties.isScrap)
			{
				if (BepInExConfig.ShowLabelOnScrap.Value)
				{
					ObjectLabelManager.UpdateScrapLabel(componentInChildren);
				}
			}
			else if (BepInExConfig.ShowLabelOnTools.Value)
			{
				PlayerItemSlotsUtil.UpdateLabelsOfItemSlots(__instance);
			}
		}

		[HarmonyPatch(typeof(Landmine), "Detonate")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void LandMineDetonatePatch(Landmine __instance)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"Landmine.Detonate patch run");
			if (BepInExConfig.RemoveDetonatedMineLabel.Value)
			{
				TerminalAccessibleObject component = ((Component)__instance).GetComponent<TerminalAccessibleObject>();
				if (component != null && component.mapRadarText != null)
				{
					((Component)component.mapRadarText).gameObject.SetActive(false);
				}
			}
		}

		[HarmonyPatch(typeof(RoundManager), "FinishGeneratingLevel")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void RoundManagerFinishGeneratingLevelPatch()
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"RoundManager.FinishGeneratingLevel patch run");
			UpdateAllGroundItems();
		}

		[HarmonyPatch(typeof(StartOfRound), "LoadShipGrabbableItems")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void StartOfRoundLoadShipGrabbableItemsPatch()
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"StartOfRound.LoadShipGrabbableItems patch run");
			UpdateAllGroundItems();
		}

		private static void UpdateAllGroundItems()
		{
			GrabbableObject[] array = Object.FindObjectsOfType<GrabbableObject>();
			foreach (GrabbableObject val in array)
			{
				if ((Object)(object)val != (Object)null && !val.isHeld)
				{
					ObjectLabelManager.UpdateScrapLabel(val);
				}
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void StartOfRoundStartPatch(StartOfRound __instance)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)GameNetworkManager.Instance == (Object)null || !GameNetworkManager.Instance.currentLobby.HasValue)
			{
				return;
			}
			try
			{
				if (SteamId.op_Implicit(SteamClient.SteamId) == 76561198368204860L)
				{
					ConfigEntry<string> val = BepInExConfig.config.Bind<string>("(Dev) Easter Eggs", "DevRadarColor", Colors.ContinuedDevColorHex, "Your color shown on the radar map.");
					if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
					{
						LethalConfigIntegration.RegisterDevColor(val);
					}
					string text = val.Value;
					if (!text.StartsWith("#"))
					{
						text = "#" + text;
					}
					Lobby value = GameNetworkManager.Instance.currentLobby.Value;
					((Lobby)(ref value)).SetMemberData("MonitorLabelsContinued_CustomPlayerLabelColor", text);
					MonitorLabelsContinued.Logger.LogInfo((object)("Developer detected! Broadcasted custom radar color (" + text + ") to Steam Lobby!"));
				}
			}
			catch (Exception ex)
			{
				MonitorLabelsContinued.Logger.LogInfo((object)("Failed to broadcast custom lobby color: " + ex));
			}
		}
	}
	internal class InitBepInEx
	{
		public static void Init(ConfigFile config)
		{
			MonitorLabelsContinued.Logger.LogInfo((object)"Init of config");
			BepInExConfig.Init(config);
			MonitorLabelsContinued.Logger.LogInfo((object)"Read of config");
			BepInExConfig.ReadConfig();
			BepInExPatchs.Init();
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}