using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BetterTeleporter.Config;
using BetterTeleporter.Patches;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("BetterTeleporter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Better Teleporters for Lethal Company")]
[assembly: AssemblyFileVersion("1.2.2.0")]
[assembly: AssemblyInformationalVersion("1.2.2+6f19cf163f211303c2d14af744a1a73efc7d0d4d")]
[assembly: AssemblyProduct("BetterTeleporter")]
[assembly: AssemblyTitle("BetterTeleporter")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BetterTeleporter
{
	[BepInPlugin("BetterTeleporter", "BetterTeleporter", "1.2.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("BetterTeleporter");

		internal static ManualLogSource log;

		public static Plugin instance { get; private set; }

		private void Awake()
		{
			instance = this;
			log = ((BaseUnityPlugin)this).Logger;
			ConfigSettings.Bind();
			harmony.PatchAll(typeof(ConfigSync));
			harmony.PatchAll(typeof(ShipTeleporterPatch));
			harmony.PatchAll(typeof(StartOfRoundPatch));
			log.LogInfo((object)"Plugin BetterTeleporter is loaded!");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BetterTeleporter";

		public const string PLUGIN_NAME = "BetterTeleporter";

		public const string PLUGIN_VERSION = "1.2.2";
	}
}
namespace BetterTeleporter.Config
{
	public static class ConfigSettings
	{
		public static int cooldownAmmount;

		public static int cooldownAmmountInverse;

		public static bool cooldownEnd;

		public static string[] keepListItems;

		public static string[] keepListItemsInverse;

		public static string[] keepListLethalThingsItems;

		public static bool doDrainItems;

		public static float drainItemsPercent;

		public static ConfigEntry<int> cooldown;

		public static ConfigEntry<int> cooldownInverse;

		public static ConfigEntry<bool> cooldownEndDay;

		public static ConfigEntry<string> keepList;

		public static ConfigEntry<string> keepListInverse;

		public static ConfigEntry<string> keepListLethalThings;

		public static ConfigEntry<bool> doDrain;

		public static ConfigEntry<float> drainPercent;

		public static void Bind()
		{
			cooldown = ((BaseUnityPlugin)Plugin.instance).Config.Bind<int>("General", "Cooldown", 10, "Number of seconds between teleporter uses");
			cooldownInverse = ((BaseUnityPlugin)Plugin.instance).Config.Bind<int>("General", "CooldownInverse", 210, "Number of seconds between teleporter uses");
			cooldownEndDay = ((BaseUnityPlugin)Plugin.instance).Config.Bind<bool>("General", "CooldownEndsOnNewDay", true, "true/false if cooldown should end on new day");
			keepList = ((BaseUnityPlugin)Plugin.instance).Config.Bind<string>("General", "KeepItemList", "KeyItem,FlashlightItem,WalkieTalkie", "Comma-seperated list of items to be kept when teleported");
			keepListInverse = ((BaseUnityPlugin)Plugin.instance).Config.Bind<string>("General", "KeepItemListInverse", "KeyItem,FlashlightItem,WalkieTalkie,RadarBoosterItem", "Comma-seperated list of items to be kept when teleported with inverse teleporter");
			keepListLethalThings = ((BaseUnityPlugin)Plugin.instance).Config.Bind<string>("General", "KeepItemListLethalThings", "PouchyBelt", "Comma-seperated list of items to be kept when teleported with inverse and normal teleporter, but with LethalThings Items");
			doDrain = ((BaseUnityPlugin)Plugin.instance).Config.Bind<bool>("General", "DrainItem", true, "true/false if items should drain battery charge");
			drainPercent = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("General", "DrainPercent", 0.5f, "The percentage (as float 0 to 1) of total charge that battery items lose when teleporting");
			cooldownAmmount = cooldown.Value;
			cooldownAmmountInverse = cooldownInverse.Value;
			cooldownEnd = cooldownEndDay.Value;
			SetKeepList(keepList.Value);
			SetKeepList(keepListInverse.Value, inverse: true);
			SetKeepListLethalThings(keepListLethalThings.Value);
			doDrainItems = doDrain.Value;
			drainItemsPercent = drainPercent.Value;
		}

		public static void SetKeepList(string list, bool inverse = false)
		{
			if (inverse)
			{
				keepListItemsInverse = list.Split(',');
				for (int i = 0; i < keepListItemsInverse.Length; i++)
				{
					keepListItemsInverse[i] = keepListItemsInverse[i].Trim();
				}
			}
			else
			{
				keepListItems = list.Split(',');
				for (int j = 0; j < keepListItems.Length; j++)
				{
					keepListItems[j] = keepListItems[j].Trim();
				}
			}
		}

		public static void SetKeepListLethalThings(string list)
		{
			keepListLethalThingsItems = list.Split(',');
			for (int i = 0; i < keepListLethalThingsItems.Length; i++)
			{
				keepListLethalThingsItems[i] = keepListLethalThingsItems[i].Trim();
				keepListLethalThingsItems[i] = "LethalThings." + keepListLethalThingsItems[i];
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class ConfigSync
	{
		[HarmonyPatch("ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void InitializeLocalPlayer()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (NetworkManager.Singleton.IsServer)
			{
				NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterTeleporterConfigSync", new HandleNamedMessageDelegate(OnReceiveConfigSyncRequest));
				return;
			}
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterTeleporterReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveConfigSync));
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterTeleporterReceiveConfigSync_KeepList", new HandleNamedMessageDelegate(OnReceiveConfigSync_KeepList));
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterTeleporterReceiveConfigSync_KeepListInverse", new HandleNamedMessageDelegate(OnReceiveConfigSync_KeepListInverse));
			NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterTeleporterReceiveConfigSync_KeepListLethalThings", new HandleNamedMessageDelegate(OnReceiveConfigSync_KeepListLethalThings));
			RequestConfigSync();
		}

		public static void RequestConfigSync()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsClient)
			{
				Plugin.log.LogInfo((object)"Sending config sync request to server.");
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(16, (Allocator)2, -1);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterTeleporterConfigSync", 0uL, val, (NetworkDelivery)3);
			}
			else
			{
				Plugin.log.LogWarning((object)"Failed to send config sync request.");
			}
		}

		public static void OnReceiveConfigSyncRequest(ulong clientId, FastBufferReader reader)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				Plugin.log.LogInfo((object)("Receiving sync request from client with id: " + clientId + ". Sending config sync to client."));
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(14, (Allocator)2, -1);
				int value = ConfigSettings.cooldown.Value;
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref value, default(ForPrimitives));
				value = ConfigSettings.cooldownInverse.Value;
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref value, default(ForPrimitives));
				bool value2 = ConfigSettings.cooldownEndDay.Value;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref value2, default(ForPrimitives));
				value2 = ConfigSettings.doDrain.Value;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref value2, default(ForPrimitives));
				float value3 = ConfigSettings.drainPercent.Value;
				((FastBufferWriter)(ref val)).WriteValueSafe<float>(ref value3, default(ForPrimitives));
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterTeleporterReceiveConfigSync", clientId, val, (NetworkDelivery)3);
				FastBufferWriter val2 = default(FastBufferWriter);
				((FastBufferWriter)(ref val2))..ctor(ConfigSettings.keepList.Value.Length * 2, (Allocator)2, -1);
				((FastBufferWriter)(ref val2)).WriteValueSafe(ConfigSettings.keepList.Value, true);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterTeleporterReceiveConfigSync_KeepList", clientId, val2, (NetworkDelivery)3);
				FastBufferWriter val3 = default(FastBufferWriter);
				((FastBufferWriter)(ref val3))..ctor(ConfigSettings.keepListInverse.Value.Length * 2, (Allocator)2, -1);
				((FastBufferWriter)(ref val3)).WriteValueSafe(ConfigSettings.keepListInverse.Value, true);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterTeleporterReceiveConfigSync_KeepListInverse", clientId, val3, (NetworkDelivery)3);
				FastBufferWriter val4 = default(FastBufferWriter);
				((FastBufferWriter)(ref val4))..ctor(ConfigSettings.keepListLethalThings.Value.Length * 2, (Allocator)2, -1);
				((FastBufferWriter)(ref val4)).WriteValueSafe(ConfigSettings.keepListLethalThings.Value, true);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterTeleporterReceiveConfigSync_KeepListLethalThings", clientId, val4, (NetworkDelivery)3);
			}
		}

		public static void OnReceiveConfigSync(ulong clientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_0053: 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_005b: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: 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_0102: Unknown result type (might be due to invalid IL or missing references)
			FastBufferReader val = reader;
			if (((FastBufferReader)(ref val)).TryBeginRead(4))
			{
				Plugin.log.LogInfo((object)"Receiving sync from server.");
				val = reader;
				int num = default(int);
				((FastBufferReader)(ref val)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				ConfigSettings.cooldownAmmount = num;
				Plugin.log.LogInfo((object)$"Recieved 'cooldownAmmount = {num}");
				val = reader;
				int num2 = default(int);
				((FastBufferReader)(ref val)).ReadValueSafe<int>(ref num2, default(ForPrimitives));
				ConfigSettings.cooldownAmmountInverse = num2;
				Plugin.log.LogInfo((object)$"Recieved 'cooldownAmmountInverse = {num2}");
				val = reader;
				bool flag = default(bool);
				((FastBufferReader)(ref val)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				ConfigSettings.cooldownEnd = flag;
				Plugin.log.LogInfo((object)$"Recieved 'cooldownEnd = {flag}");
				val = reader;
				bool flag2 = default(bool);
				((FastBufferReader)(ref val)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				ConfigSettings.doDrainItems = flag2;
				Plugin.log.LogInfo((object)$"Recieved 'doDrainItems = {flag2}");
				val = reader;
				float num3 = default(float);
				((FastBufferReader)(ref val)).ReadValueSafe<float>(ref num3, default(ForPrimitives));
				ConfigSettings.drainItemsPercent = num3;
				Plugin.log.LogInfo((object)$"Recieved 'drainItemsPercent = {num3}");
			}
			else
			{
				Plugin.log.LogWarning((object)"Error receiving config sync from server.");
			}
		}

		public static void OnReceiveConfigSync_KeepList(ulong clientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			FastBufferReader val = reader;
			if (((FastBufferReader)(ref val)).TryBeginRead(4))
			{
				Plugin.log.LogInfo((object)"Receiving sync from server.");
				val = reader;
				string text = default(string);
				((FastBufferReader)(ref val)).ReadValueSafe(ref text, true);
				ConfigSettings.SetKeepList(text);
				Plugin.log.LogInfo((object)("Recieved 'keepList = " + text));
			}
			else
			{
				Plugin.log.LogWarning((object)"Error receiving keepList config sync from server.");
			}
		}

		public static void OnReceiveConfigSync_KeepListInverse(ulong clientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			FastBufferReader val = reader;
			if (((FastBufferReader)(ref val)).TryBeginRead(4))
			{
				Plugin.log.LogInfo((object)"Receiving sync from server.");
				val = reader;
				string text = default(string);
				((FastBufferReader)(ref val)).ReadValueSafe(ref text, true);
				ConfigSettings.SetKeepList(text, inverse: true);
				Plugin.log.LogInfo((object)("Recieved 'keepListInverse = " + text));
			}
			else
			{
				Plugin.log.LogWarning((object)"Error receiving keepListInverse config sync from server.");
			}
		}

		public static void OnReceiveConfigSync_KeepListLethalThings(ulong clientId, FastBufferReader reader)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			FastBufferReader val = reader;
			if (((FastBufferReader)(ref val)).TryBeginRead(4))
			{
				Plugin.log.LogInfo((object)"Receiving sync from server.");
				val = reader;
				string text = default(string);
				((FastBufferReader)(ref val)).ReadValueSafe(ref text, true);
				ConfigSettings.SetKeepListLethalThings(text);
				Plugin.log.LogInfo((object)("Recieved 'keepListLethalThings = " + text));
			}
			else
			{
				Plugin.log.LogWarning((object)"Error receiving keepListLethalThings config sync from server.");
			}
		}
	}
}
namespace BetterTeleporter.Patches
{
	[HarmonyPatch(typeof(ShipTeleporter))]
	public class ShipTeleporterPatch
	{
		private static readonly CodeMatch[] inverseTeleporterPatchIlMatch = (CodeMatch[])(object)new CodeMatch[4]
		{
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.IsLdloc(i, (LocalBuilder)null)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.LoadsConstant(i, 1L)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.LoadsConstant(i, 0L)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, originalMethodInfo)), (string)null)
		};

		private static readonly CodeMatch[] teleporterPatchIlMatch = (CodeMatch[])(object)new CodeMatch[5]
		{
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.IsLdarg(i, (int?)0)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldfld), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.LoadsConstant(i, 1L)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.LoadsConstant(i, 0L)), (string)null),
			new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => CodeInstructionExtensions.Calls(i, originalMethodInfo)), (string)null)
		};

		private static readonly MethodInfo originalMethodInfo = typeof(PlayerControllerB).GetMethod("DropAllHeldItems", BindingFlags.Instance | BindingFlags.Public);

		private static readonly MethodInfo replaceMethodInfo = typeof(ShipTeleporterPatch).GetMethod("DropSomeItems", BindingFlags.Static | BindingFlags.NonPublic);

		[HarmonyTranspiler]
		[HarmonyPatch("TeleportPlayerOutWithInverseTeleporter")]
		public static IEnumerable<CodeInstruction> InverseTeleporterDropAllButHeldItem(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.Start();
			val.MatchForward(false, inverseTeleporterPatchIlMatch);
			val.Advance(1);
			val.RemoveInstructionsWithOffsets(0, 2);
			val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)1)
			});
			val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldc_I4_1, (object)1)
			});
			val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Callvirt, (object)replaceMethodInfo)
			});
			Plugin.log.LogInfo((object)"Patched 'ShipTeleporterPatch.TeleportPlayerOutWithInverseTeleporter'");
			return val.Instructions();
		}

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static IEnumerable<CodeInstruction> TeleporterDropAllButHeldItem(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.End();
			val.MatchBack(false, teleporterPatchIlMatch);
			val.Advance(2);
			val.RemoveInstructionsWithOffsets(0, 2);
			val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldc_I4_0, (object)0)
			});
			val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldc_I4_1, (object)1)
			});
			val.Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Callvirt, (object)replaceMethodInfo)
			});
			Plugin.log.LogInfo((object)"Patched 'ShipTeleporterPatch.beamUpPlayer'");
			return val.Instructions();
		}

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void Awake(ref bool ___isInverseTeleporter, ref float ___cooldownAmount)
		{
			if (___isInverseTeleporter)
			{
				___cooldownAmount = ConfigSettings.cooldownAmmountInverse;
			}
			else
			{
				___cooldownAmount = ConfigSettings.cooldownAmmount;
			}
		}

		private static void DropSomeItems(PlayerControllerB player, bool inverse = false, bool itemsFall = true)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			MethodInfo method = ((object)player).GetType().GetMethod("SetSpecialGrabAnimationBool", BindingFlags.Instance | BindingFlags.NonPublic);
			string[] source = ConfigSettings.keepListItems;
			if (inverse)
			{
				source = ConfigSettings.keepListItemsInverse;
			}
			string[] keepListLethalThingsItems = ConfigSettings.keepListLethalThingsItems;
			float num = 1f;
			bool twoHanded = false;
			for (int i = 0; i < player.ItemSlots.Length; i++)
			{
				GrabbableObject val = player.ItemSlots[i];
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				if (source.Contains(((object)val).GetType().ToString()) || keepListLethalThingsItems.Contains<string>(((object)val).GetType().FullName))
				{
					if (val.insertedBattery != null && ConfigSettings.doDrainItems)
					{
						float num2 = val.insertedBattery.charge - val.insertedBattery.charge * ConfigSettings.drainItemsPercent;
						if (num2 < 0f)
						{
							num2 = 0f;
						}
						val.insertedBattery = new Battery(num2 != 0f, num2);
						val.SyncBatteryServerRpc((int)(num2 * 100f));
					}
					num += Mathf.Clamp(val.itemProperties.weight - 1f, 0f, 10f);
					continue;
				}
				if (itemsFall)
				{
					val.parentObject = null;
					val.heldByPlayerOnServer = false;
					if (player.isInElevator)
					{
						((Component)val).transform.SetParent(player.playersManager.elevatorTransform, true);
					}
					else
					{
						((Component)val).transform.SetParent(player.playersManager.propsContainer, true);
					}
					player.SetItemInElevator(player.isInHangarShipRoom, player.isInElevator, val);
					val.EnablePhysics(true);
					val.EnableItemMeshes(true);
					((Component)val).transform.localScale = val.originalScale;
					val.isHeld = false;
					val.isPocketed = false;
					val.startFallingPosition = ((Component)val).transform.parent.InverseTransformPoint(((Component)val).transform.position);
					val.FallToGround(true);
					val.fallTime = Random.Range(-0.3f, 0.05f);
					if (((NetworkBehaviour)player).IsOwner)
					{
						val.DiscardItemOnClient();
					}
					else if (!val.itemProperties.syncDiscardFunction)
					{
						val.playerHeldBy = null;
					}
				}
				if (((NetworkBehaviour)player).IsOwner)
				{
					((Behaviour)HUDManager.Instance.holdingTwoHandedItem).enabled = false;
					((Behaviour)HUDManager.Instance.itemSlotIcons[i]).enabled = false;
					HUDManager.Instance.ClearControlTips();
					player.activatingItem = false;
				}
				player.ItemSlots[i] = null;
			}
			GrabbableObject val2 = player.ItemSlots[player.currentItemSlot];
			if ((Object)(object)val2 == (Object)null)
			{
				player.isHoldingObject = false;
				if ((Object)(object)player.currentlyHeldObjectServer != (Object)null)
				{
					method.Invoke(player, new object[2] { false, player.currentlyHeldObjectServer });
				}
				player.playerBodyAnimator.SetBool("cancelHolding", true);
				player.playerBodyAnimator.SetTrigger("Throw");
			}
			else
			{
				twoHanded = val2.itemProperties.twoHanded;
			}
			player.twoHanded = twoHanded;
			player.carryWeight = num;
			player.currentlyHeldObjectServer = val2;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		private static readonly FieldInfo cooldownProp = typeof(ShipTeleporter).GetField("cooldownTime", BindingFlags.Instance | BindingFlags.NonPublic);

		[HarmonyPatch("StartGame")]
		[HarmonyPostfix]
		private static void StartGame()
		{
			if (ConfigSettings.cooldownEnd)
			{
				ResetCooldown();
			}
		}

		[HarmonyPatch("EndOfGame")]
		[HarmonyPostfix]
		private static void EndOfGame()
		{
			if (ConfigSettings.cooldownEnd)
			{
				ResetCooldown();
			}
		}

		[HarmonyPatch("EndOfGameClientRpc")]
		[HarmonyPostfix]
		private static void EndOfGameClientRpc()
		{
			if (ConfigSettings.cooldownEnd)
			{
				ResetCooldown();
			}
		}

		private static void ResetCooldown()
		{
			ShipTeleporter[] array = Object.FindObjectsOfType<ShipTeleporter>();
			foreach (ShipTeleporter obj in array)
			{
				cooldownProp.SetValue(obj, 0f);
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
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.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("ShipScanRange")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("The main entrance and ship can be scanned from any range, ignoring LOS. This makes it easier to find your way around the map, especially for custom maps. The item dropship has the same properties applied if another mod enables it to be scanned (e.g. GeneralImprovements)")]
[assembly: AssemblyFileVersion("0.0.1.0")]
[assembly: AssemblyInformationalVersion("0.0.1")]
[assembly: AssemblyProduct("ShipScanRange")]
[assembly: AssemblyTitle("ShipScanRange")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ShipScanRange
{
	[BepInPlugin("DBJ.ShipScanRange", "ShipScanRange", "1.0.0")]
	public class ShipScanRangeBase : BaseUnityPlugin
	{
		private const string modGUID = "DBJ.ShipScanRange";

		private const string modName = "Ship Scan Range";

		private const string modVersion = "0.0.1";

		public static readonly string[] scannables = new string[3] { "ship", "main entrance", "dropship" };

		private readonly Harmony harmony = new Harmony("DBJ.ShipScanRange");

		public static ManualLogSource mls;

		private void Awake()
		{
			mls = Logger.CreateLogSource("DBJ.ShipScanRange");
			harmony.PatchAll();
			foreach (MethodBase patchedMethod in harmony.GetPatchedMethods())
			{
				mls.LogInfo((object)(patchedMethod.ToString() + " patched."));
			}
			mls.LogInfo((object)"Ship Scan Range has loaded!");
		}
	}
	[HarmonyPatch(typeof(HUDManager))]
	public class AssignNewNodesPatch
	{
		[HarmonyPatch("AssignNewNodes")]
		[HarmonyPostfix]
		public static void AssignNewNodes(PlayerControllerB playerScript)
		{
			if (playerScript.isInsideFactory || HUDManager.Instance.nodesOnScreen.Count >= HUDManager.Instance.scanElements.Length)
			{
				return;
			}
			Plane[] camPlanes = GeometryUtility.CalculateFrustumPlanes(playerScript.gameplayCamera);
			IOrderedEnumerable<KeyValuePair<string, ScanNodeProperties>> orderedEnumerable = from s in (from s in Object.FindObjectsOfType<ScanNodeProperties>()
					select new KeyValuePair<string, ScanNodeProperties>(s.headerText.ToLower(), s)).Where(delegate(KeyValuePair<string, ScanNodeProperties> s)
				{
					//IL_003f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0044: Unknown result type (might be due to invalid IL or missing references)
					//IL_0049: Unknown result type (might be due to invalid IL or missing references)
					Collider component = ((Component)s.Value).GetComponent<Collider>();
					return component != null && component.enabled && ShipScanRangeBase.scannables.Contains(s.Key) && GeometryUtility.TestPlanesAABB(camPlanes, new Bounds(((Component)s.Value).transform.position, Vector3.one));
				})
				orderby s.Key == "ship" descending
				select s;
			CollectionExtensions.Do<KeyValuePair<string, ScanNodeProperties>>((IEnumerable<KeyValuePair<string, ScanNodeProperties>>)orderedEnumerable, (Action<KeyValuePair<string, ScanNodeProperties>>)delegate(KeyValuePair<string, ScanNodeProperties> s)
			{
				ScanNodeProperties value = s.Value;
				int maxRange;
				if (!(s.Key != "dropship"))
				{
					ItemDropship obj = Object.FindAnyObjectByType<ItemDropship>();
					if (obj == null || !obj.deliveringOrder)
					{
						maxRange = 0;
						goto IL_0036;
					}
				}
				maxRange = 1000;
				goto IL_0036;
				IL_0036:
				value.maxRange = maxRange;
				s.Value.requiresLineOfSight = false;
				if (HUDManager.Instance.nodesOnScreen.Count < HUDManager.Instance.scanElements.Length)
				{
					HUDManager.Instance.AttemptScanNode(s.Value, HUDManager.Instance.nodesOnScreen.Count, playerScript);
				}
			});
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "ShipScanRange";

		public const string PLUGIN_NAME = "ShipScanRange";

		public const string PLUGIN_VERSION = "0.0.1";
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ShipLoot")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("ShipLoot")]
[assembly: AssemblyCopyright("Copyright © tinyhoot 2023")]
[assembly: ComVisible(false)]
[assembly: AssemblyFileVersion("1.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace ShipLoot
{
	[BepInPlugin("com.github.tinyhoot.ShipLoot", "ShipLoot", "1.0")]
	internal class ShipLoot : BaseUnityPlugin
	{
		public const string GUID = "com.github.tinyhoot.ShipLoot";

		public const string NAME = "ShipLoot";

		public const string VERSION = "1.0";

		internal static ManualLogSource Log;

		private void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			new Harmony("com.github.tinyhoot.ShipLoot").PatchAll(Assembly.GetExecutingAssembly());
		}
	}
}
namespace ShipLoot.Patches
{
	[HarmonyPatch]
	internal class HudManagerPatcher
	{
		private static GameObject _totalCounter;

		private static TextMeshProUGUI _textMesh;

		private static float _displayTimeLeft;

		private const float DisplayTime = 5f;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
		private static void OnScan(HUDManager __instance, CallbackContext context)
		{
			if (!((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null) && ((CallbackContext)(ref context)).performed && __instance.CanPlayerScan() && !(__instance.playerPingingScan > -0.5f) && (StartOfRound.Instance.inShipPhase || GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom))
			{
				if (!Object.op_Implicit((Object)(object)_totalCounter))
				{
					CopyValueCounter();
				}
				float num = CalculateLootValue();
				((TMP_Text)_textMesh).text = $"SHIP: ${num:F0}";
				_displayTimeLeft = 5f;
				if (!_totalCounter.activeSelf)
				{
					((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(ShipLootCoroutine());
				}
			}
		}

		private static IEnumerator ShipLootCoroutine()
		{
			_totalCounter.SetActive(true);
			while (_displayTimeLeft > 0f)
			{
				float displayTimeLeft = _displayTimeLeft;
				_displayTimeLeft = 0f;
				yield return (object)new WaitForSeconds(displayTimeLeft);
			}
			_totalCounter.SetActive(false);
		}

		private static float CalculateLootValue()
		{
			List<GrabbableObject> list = (from obj in GameObject.Find("/Environment/HangarShip").GetComponentsInChildren<GrabbableObject>()
				where ((Object)obj).name != "ClipboardManual" && ((Object)obj).name != "StickyNoteItem"
				select obj).ToList();
			ShipLoot.Log.LogDebug((object)"Calculating total ship scrap value.");
			CollectionExtensions.Do<GrabbableObject>((IEnumerable<GrabbableObject>)list, (Action<GrabbableObject>)delegate(GrabbableObject scrap)
			{
				ShipLoot.Log.LogDebug((object)$"{((Object)scrap).name} - ${scrap.scrapValue}");
			});
			return list.Sum((GrabbableObject scrap) => scrap.scrapValue);
		}

		private static void CopyValueCounter()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("/Systems/UI/Canvas/IngamePlayerHUD/BottomMiddle/ValueCounter");
			if (!Object.op_Implicit((Object)(object)val))
			{
				ShipLoot.Log.LogError((object)"Failed to find ValueCounter object to copy!");
			}
			_totalCounter = Object.Instantiate<GameObject>(val.gameObject, val.transform.parent, false);
			_totalCounter.transform.Translate(0f, 1f, 0f);
			Vector3 localPosition = _totalCounter.transform.localPosition;
			_totalCounter.transform.localPosition = new Vector3(localPosition.x + 50f, -50f, localPosition.z);
			_textMesh = _totalCounter.GetComponentInChildren<TextMeshProUGUI>();
		}
	}
}

using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BiggerBattery")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BiggerBattery")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1BFEAD94-08B6-4FCB-88CA-11E8762E4A12")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BiggerBattery
{
	public static class ConfigSettings
	{
		public static ConfigEntry<float> FlashlightBatteryUsage;

		public static ConfigEntry<float> ProFlashlightBatteryUsage;

		public static ConfigEntry<float> LaserPointerBatteryUsage;

		public static ConfigEntry<float> WalkieTalkieBatteryUsage;

		public static ConfigEntry<float> JetpackBatteryUsage;

		public static ConfigEntry<float> PatcherToolBatteryUsage;

		public static ConfigEntry<float> BoomboxItemBatteryUsage;

		public static void Init()
		{
			FlashlightBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "FlashlightBatteryUsage", 300f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 140)");
			ProFlashlightBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "ProFlashlightBatteryUsage", 600f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 300)");
			LaserPointerBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "LaserPointerBatteryUsage", 450f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 300)");
			WalkieTalkieBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "WalkieTalkieBatteryUsage", 1500f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 820)");
			JetpackBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "JetpackBatteryUsage", 140f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 60)");
			PatcherToolBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "PatcherToolBatteryUsage", 66f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 22)");
			BoomboxItemBatteryUsage = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>("BiggerBattery", "BoomboxItemBatteryUsage", 600f, "The battery usage per update. The lower the value, the shorter the battery life. (Game Default: 350)");
		}
	}
	public enum FlashlightType
	{
		ProFlashlight,
		Flashlight,
		LaserPointer
	}
	[BepInPlugin("dev.alexanderdiaz.biggerbattery", "Bigger Battery", "1.0.2")]
	public class Plugin : BaseUnityPlugin
	{
		private const string ModGuid = "dev.alexanderdiaz.biggerbattery";

		private const string ModName = "Bigger Battery";

		private const string ModVersion = "1.0.2";

		private readonly Harmony _harmony = new Harmony("dev.alexanderdiaz.biggerbattery");

		public static Plugin Instance;

		private void Awake()
		{
			Instance = this;
			_harmony.PatchAll();
			ConfigSettings.Init();
			Log("Plugin Bigger Battery-1.0.2 loaded!");
		}

		public static void Log(string message)
		{
			((BaseUnityPlugin)Instance).Logger.LogInfo((object)message);
		}
	}
	public class PluginInfo
	{
		public const string PLUGIN_GUID = "dev.alexanderdiaz.biggerbattery";

		public const string PLUGIN_NAME = "Bigger Battery";

		public const string PLUGIN_VERSION = "1.0.2";
	}
}
namespace BiggerBattery.Patches
{
	[HarmonyPatch(typeof(FlashlightItem))]
	internal class FlashlightItemPatch
	{
		[HarmonyPatch("ItemActivate")]
		[HarmonyPrefix]
		private static void ModifyFlashlightBatteryUsage(ref FlashlightItem __instance)
		{
			FlashlightType flashlightTypeID = (FlashlightType)__instance.flashlightTypeID;
			switch (flashlightTypeID)
			{
			case FlashlightType.ProFlashlight:
				((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.ProFlashlightBatteryUsage.Value;
				break;
			case FlashlightType.Flashlight:
				((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.FlashlightBatteryUsage.Value;
				break;
			case FlashlightType.LaserPointer:
				((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.LaserPointerBatteryUsage.Value;
				break;
			default:
				Plugin.Log($"Unknown FlashlightType: {flashlightTypeID}");
				break;
			}
		}
	}
	[HarmonyPatch(typeof(JetpackItem))]
	internal class JetpackItemPatch
	{
		[HarmonyPatch("ItemActivate")]
		[HarmonyPrefix]
		private static void ModifyJetpackBatteryUsage(ref JetpackItem __instance)
		{
			((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.JetpackBatteryUsage.Value;
		}
	}
	[HarmonyPatch(typeof(PatcherTool))]
	internal class PatcherToolPatch
	{
		[HarmonyPatch("ItemActivate")]
		[HarmonyPrefix]
		private static void ModifyPatcherToolBatteryUsage(ref PatcherTool __instance)
		{
			((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.PatcherToolBatteryUsage.Value;
		}
	}
	[HarmonyPatch(typeof(BoomboxItem))]
	internal class BoomboxItemPatch
	{
		[HarmonyPatch("ItemActivate")]
		[HarmonyPrefix]
		private static void ModifyBoomboxItemBatteryUsage(ref BoomboxItem __instance)
		{
			((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.BoomboxItemBatteryUsage.Value;
		}
	}
	[HarmonyPatch(typeof(WalkieTalkie))]
	internal class WalkieTalkieItemPatch
	{
		[HarmonyPatch("ItemActivate")]
		[HarmonyPostfix]
		private static void ModifyWalkieTalkieBatteryUsage(ref WalkieTalkie __instance)
		{
			((GrabbableObject)__instance).itemProperties.batteryUsage = ConfigSettings.WalkieTalkieBatteryUsage.Value;
		}
	}
}

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using Microsoft.CodeAnalysis;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using UnityEngine;
using UnityEngine.UI;
using Utils;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
[BepInPlugin("flowerwater.liquidStainRemover", "LiquidStain Remover", "1.1.9")]
public class LiquidStainRemoverPlugin : BaseUnityPlugin
{
	public const string ModGuid = "flowerwater.liquidStainRemover";

	public const string ModName = "LiquidStain Remover";

	public const string ModVersion = "1.1.9";

	public static ConfigEntry<bool> disableLogoChanges;

	public static byte[] logo;

	public static Sprite logo2;

	private void Awake()
	{
		//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
		disableLogoChanges = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "Disable Logo Changes", true, "Prevents the Logo from being changed aswell. (Technically this pulls a random image from the Folder™\ufe0f and uses that for the logo so this can be used to have random logos if you want to.)");
		ToolModules.InitHooks();
		string path = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location), "Folder");
		int num = Random.Range(0, Directory.GetFiles(path).Length);
		int num2 = 0;
		string[] files = Directory.GetFiles(path);
		foreach (string path2 in files)
		{
			if (num2 == num)
			{
				logo = File.ReadAllBytes(path2);
			}
			num2++;
		}
		Texture2D val = LoadTexture(logo, 545, 249);
		logo2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(272.5f, 124.5f), 100f, 1u, (SpriteMeshType)1, new Vector4(0f, 0f, 0f, 0f), true);
	}

	public static Texture2D LoadTexture(byte[] bytes, int width, int height)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		Texture2D val = new Texture2D(width, height, (TextureFormat)5, false, false);
		ImageConversion.LoadImage(val, bytes);
		((Texture)val).filterMode = (FilterMode)0;
		return val;
	}
}
[DefaultExecutionOrder(-1)]
internal static class ToolModules
{
	private static Hook? menuManagerUpdateHook;

	private static Hook? menuManagerStartHook;

	private static Transform? loadingScreenImageTransform;

	private static Transform? headerImageTransform;

	private static Transform? loadingImageTransform;

	private static Sprite OriginalLogo;

	public static void InitHooks()
	{
		menuManagerUpdateHook = HookUtils.NewHook<MenuManager>("Update", typeof(ToolModules), "OnMenuManagerUpdate");
		menuManagerUpdateHook = HookUtils.NewHook<MenuManager>("Start", typeof(ToolModules), "OnMenuManagerStart");
	}

	private static void OnMenuManagerUpdate(Action<MenuManager> orig, MenuManager self)
	{
		orig(self);
		try
		{
			if (loadingScreenImageTransform != null)
			{
				Graphic[] componentsInChildren = ((Component)loadingScreenImageTransform).GetComponentsInChildren<Graphic>();
				foreach (Graphic val in componentsInChildren)
				{
					if (!((Object)(object)((Component)val).transform == (Object)(object)loadingScreenImageTransform))
					{
						((Behaviour)val).enabled = false;
					}
				}
			}
			if (headerImageTransform != null)
			{
				Graphic[] componentsInChildren2 = ((Component)headerImageTransform).GetComponentsInChildren<Graphic>();
				foreach (Graphic val2 in componentsInChildren2)
				{
					if (!((Object)(object)((Component)val2).transform == (Object)(object)headerImageTransform))
					{
						((Behaviour)val2).enabled = false;
					}
				}
			}
			if (LiquidStainRemoverPlugin.disableLogoChanges.Value)
			{
				try
				{
					((Component)headerImageTransform).GetComponent<Image>().overrideSprite = LiquidStainRemoverPlugin.logo2;
				}
				catch (Exception)
				{
				}
				try
				{
					((Component)loadingImageTransform).GetComponent<Image>().sprite = LiquidStainRemoverPlugin.logo2;
					return;
				}
				catch (Exception)
				{
					throw;
				}
			}
		}
		catch (Exception)
		{
		}
	}

	private static void OnMenuManagerStart(Action<MenuManager> orig, MenuManager self)
	{
		//IL_019f: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			loadingScreenImageTransform = null;
			headerImageTransform = null;
			loadingImageTransform = null;
			if (loadingScreenImageTransform == null)
			{
				loadingScreenImageTransform = ((Component)self).transform.parent.Find("MenuContainer/LoadingScreen/Image");
			}
			if (headerImageTransform == null)
			{
				headerImageTransform = ((Component)self).transform.parent.Find("MenuContainer/MainButtons");
				RectTransform[] componentsInChildren = ((Component)headerImageTransform).GetComponentsInChildren<RectTransform>();
				foreach (RectTransform val in componentsInChildren)
				{
					if (((Component)val).GetComponents<Component>().Length == 3 && (Object)(object)((Component)val).gameObject != (Object)(object)((Component)headerImageTransform).gameObject && Object.op_Implicit((Object)(object)((Component)val).GetComponent<RectTransform>()) && Object.op_Implicit((Object)(object)((Component)val).GetComponent<CanvasRenderer>()) && Object.op_Implicit((Object)(object)((Component)val).GetComponent<Image>()))
					{
						headerImageTransform = ((Component)val).gameObject.transform;
						break;
					}
				}
			}
			if (loadingImageTransform == null)
			{
				loadingImageTransform = ((Component)self).transform.parent.Find("MenuContainer/LoadingScreen/Image");
			}
		}
		catch
		{
		}
		orig(self);
		Component[] components = ((Component)self).GetComponents<Component>();
		foreach (Component val2 in components)
		{
			if (((object)val2).GetType().ToString() != "UnityEngine.Transform" && ((object)val2).GetType().ToString() != "MenuManager" && ((object)val2).GetType().ToString() != "UnityEngine.AudioSource")
			{
				((Behaviour)val2).enabled = false;
			}
		}
	}
}
namespace Utils
{
	internal static class HookUtils
	{
		private const BindingFlags DefaultFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

		private const BindingFlags StaticFlags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static Hook NewHook<TTarget, TDest>(string targetMethodName, string destMethodName, TDest instance)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			MethodInfo method = typeof(TTarget).GetMethod(targetMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo method2 = typeof(TDest).GetMethod(destMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return new Hook((MethodBase)method, method2, (object)instance);
		}

		public static Hook NewHook<TTarget>(string targetMethodName, MethodInfo destMethod)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			MethodInfo method = typeof(TTarget).GetMethod(targetMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return new Hook((MethodBase)method, destMethod);
		}

		public static Hook NewHook<TTarget>(string targetMethodName, Type destType, string destMethodName)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			MethodInfo method = typeof(TTarget).GetMethod(targetMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			MethodInfo method2 = destType.GetMethod(destMethodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			return new Hook((MethodBase)method, method2);
		}

		public static ILHook NewILHook<TTarget>(string targetMethodName, Manipulator manipulator)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			MethodInfo method = typeof(TTarget).GetMethod(targetMethodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return new ILHook((MethodBase)method, manipulator);
		}
	}
}