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

[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("AccurateStaminaDisplay")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Fixes the stamina meter display on the HUD, so it more accurately represents your current stamina percentage.")]
[assembly: AssemblyFileVersion("2.1.1.0")]
[assembly: AssemblyInformationalVersion("2.1.1")]
[assembly: AssemblyProduct("AccurateStaminaDisplay")]
[assembly: AssemblyTitle("AccurateStaminaDisplay")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.1.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 AccurateStaminaDisplay
{
	internal static class NewStaminaMeter
	{
		private const float STAMINA_EMPTY = 0.1f;

		private const float STAMINA_EXHAUSTED = 0.3f;

		private const float METER_EMPTY = 0.29767f;

		private const float METER_FULL = 0.911f;

		private static readonly Color NORM_COLOR = new Color(1f, 0.4626f, 0f);

		private static readonly Color EX_COLOR = new Color(0.9f, 0.1f, 0f);

		private static PlayerControllerB player;

		private static float minStamina;

		private static bool exhausted;

		private static Image meterOverlay;

		private static readonly float OVERLAY_MAX = Mathf.Lerp(0.29767f, 0.911f, Mathf.InverseLerp(0.1f, 1f, 0.3f));

		private static Gradient tzpGrad;

		private static readonly Color LIME = new Color(0.4f, 1f, 0f);

		private const float TZP_LIGHT_MIN = 0.1f;

		private const float TZP_LIGHT_MAX = 0.2f;

		private const float TZP_HEAVY_MIN = 0.65f;

		private const float TZP_HEAVY_MAX = 0.77f;

		private static CanvasRenderer meterAlpha;

		private static CanvasRenderer overlayAlpha;

		private static readonly FieldInfo playerMovementHinderedPrev = typeof(PlayerControllerB).GetField("movementHinderedPrev", BindingFlags.Instance | BindingFlags.NonPublic);

		private static bool wasClimbing;

		internal static void UpdateMeter()
		{
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				Init();
				return;
			}
			minStamina = ((Plugin.configExhaustionIndicator.Value == ExhaustionIndicator.Empty) ? 0.3f : 0.1f);
			float num = Mathf.InverseLerp(minStamina, 1f, player.sprintMeter);
			player.sprintMeterUI.fillAmount = Mathf.Lerp(0.29767f, 0.911f, num);
			if (player.isClimbingLadder)
			{
				wasClimbing = true;
			}
			else if (player.thisController.isGrounded)
			{
				wasClimbing = false;
			}
			bool flag = (int)playerMovementHinderedPrev.GetValue(player) > 0 && !wasClimbing && !player.jetpackControls;
			bool flag2 = Plugin.configInhalantInfo.Value && player.drunkness > 0f && tzpGrad != null;
			bool flag3 = Plugin.configExhaustionIndicator.Value == ExhaustionIndicator.ChangeColor || (Plugin.configExhaustionIndicator.Value == ExhaustionIndicator.AlwaysShow && (flag || flag2));
			if (exhausted)
			{
				if (!flag3 || player.isSprinting || (player.sprintMeter >= 0.3f && !flag))
				{
					exhausted = false;
				}
			}
			else if (flag3 && (player.isExhausted || flag))
			{
				exhausted = true;
				((Graphic)player.sprintMeterUI).color = EX_COLOR;
			}
			else if (flag2)
			{
				((Graphic)player.sprintMeterUI).color = tzpGrad.Evaluate(player.drunkness);
			}
			else
			{
				((Graphic)player.sprintMeterUI).color = NORM_COLOR;
			}
			if (!((Object)(object)meterOverlay != (Object)null))
			{
				return;
			}
			if (Plugin.configExhaustionIndicator.Value == ExhaustionIndicator.AlwaysShow && !exhausted && !player.criticallyInjured && !flag2)
			{
				meterOverlay.fillAmount = Mathf.Min(player.sprintMeterUI.fillAmount, OVERLAY_MAX);
				if ((Object)(object)overlayAlpha != (Object)null)
				{
					overlayAlpha.SetAlpha(meterAlpha.GetAlpha());
				}
				((Component)meterOverlay).gameObject.SetActive(true);
			}
			else
			{
				((Component)meterOverlay).gameObject.SetActive(false);
			}
		}

		private static void Init()
		{
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: 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)
			player = GameNetworkManager.Instance.localPlayerController;
			if ((Object)(object)meterOverlay == (Object)null && (Object)(object)player != (Object)null)
			{
				meterOverlay = ((Component)Object.Instantiate<Transform>(((Component)player.sprintMeterUI).transform, ((Component)player.sprintMeterUI).transform.parent)).GetComponent<Image>();
				((Graphic)meterOverlay).color = EX_COLOR;
			}
			if (tzpGrad == null)
			{
				tzpGrad = new Gradient();
				tzpGrad.SetKeys((GradientColorKey[])(object)new GradientColorKey[6]
				{
					new GradientColorKey(NORM_COLOR, 0f),
					new GradientColorKey(Color.yellow, 0.1f),
					new GradientColorKey(Color.yellow, 0.2f),
					new GradientColorKey(LIME, 0.65f),
					new GradientColorKey(LIME, 0.77f),
					new GradientColorKey(Color.white, 1f)
				}, (GradientAlphaKey[])(object)new GradientAlphaKey[2]
				{
					new GradientAlphaKey(1f, 0f),
					new GradientAlphaKey(1f, 1f)
				});
			}
			if (Chainloader.PluginInfos.ContainsKey("ShyHUD") && (Object)(object)player != (Object)null && (Object)(object)meterOverlay != (Object)null)
			{
				meterAlpha = ((Component)player.sprintMeterUI).GetComponent<CanvasRenderer>();
				overlayAlpha = ((Component)meterOverlay).GetComponent<CanvasRenderer>();
			}
		}
	}
	internal enum ExhaustionIndicator
	{
		Empty,
		ChangeColor,
		AlwaysShow,
		DontShow
	}
	[BepInPlugin("butterystancakes.lethalcompany.accuratestaminadisplay", "Accurate Stamina Display", "2.1.1")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private const string PLUGIN_GUID = "butterystancakes.lethalcompany.accuratestaminadisplay";

		private const string PLUGIN_NAME = "Accurate Stamina Display";

		private const string PLUGIN_VERSION = "2.1.1";

		internal static ConfigEntry<bool> configInhalantInfo;

		internal static ConfigEntry<ExhaustionIndicator> configExhaustionIndicator;

		private void Awake()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			LoadConfig();
			new Harmony("butterystancakes.lethalcompany.accuratestaminadisplay").PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Accurate Stamina Display v2.1.1 loaded");
		}

		private void LoadConfig()
		{
			configInhalantInfo = ((BaseUnityPlugin)this).Config.Bind<bool>("Extra", "InhalantInfo", false, "Adjusts the color of the stamina meter to reflect the amount of TZP inhaled. (Light = yellow, heavy = green, \"overdose\" = white)");
			configExhaustionIndicator = ((BaseUnityPlugin)this).Config.Bind<ExhaustionIndicator>("Misc", "ExhaustionIndicator", ExhaustionIndicator.AlwaysShow, "How the stamina meter displays exhaustion. You become exhausted when stamina hits 0% or if you release the sprint key while stamina is 20% or lower.\n\"Empty\" will make the stamina bar display as empty for the last 20% of stamina, just like the original game. \"ChangeColor\" will turn the bar red when you are currently exhausted. \"AlwaysShow\" will always display the last 20% of the bar as red. \"DontShow\" will not display any special indicator for exhaustion.");
			if (configExhaustionIndicator.Value != ExhaustionIndicator.AlwaysShow)
			{
				return;
			}
			bool value = ((BaseUnityPlugin)this).Config.Bind<bool>("Extra", "AlwaysShowRedPortion", true, "Legacy setting, use \"ExhaustionIndicator\" instead").Value;
			bool value2 = ((BaseUnityPlugin)this).Config.Bind<bool>("Extra", "ExhaustedRed", true, "Legacy setting, use \"ExhaustionIndicator\" instead").Value;
			if (((BaseUnityPlugin)this).Config.Bind<bool>("Miscellaneous", "EmptyEarly", false, "Legacy setting, use \"ExhaustionIndicator\" instead").Value)
			{
				configExhaustionIndicator.Value = ExhaustionIndicator.Empty;
			}
			else if (value2)
			{
				if (value)
				{
					configExhaustionIndicator.Value = ExhaustionIndicator.AlwaysShow;
				}
				else
				{
					configExhaustionIndicator.Value = ExhaustionIndicator.ChangeColor;
				}
			}
			else
			{
				configExhaustionIndicator.Value = ExhaustionIndicator.DontShow;
			}
			((BaseUnityPlugin)this).Config.Remove(((BaseUnityPlugin)this).Config["Extra", "AlwaysShowRedPortion"].Definition);
			((BaseUnityPlugin)this).Config.Remove(((BaseUnityPlugin)this).Config["Extra", "ExhaustedRed"].Definition);
			((BaseUnityPlugin)this).Config.Remove(((BaseUnityPlugin)this).Config["Miscellaneous", "EmptyEarly"].Definition);
			((BaseUnityPlugin)this).Config.Save();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "AccurateStaminaDisplay";

		public const string PLUGIN_NAME = "AccurateStaminaDisplay";

		public const string PLUGIN_VERSION = "2.1.1";
	}
}
namespace AccurateStaminaDisplay.Patches
{
	[HarmonyPatch]
	internal class AccurateStaminaDisplayPatches
	{
		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPostfix]
		public static void PlayerPostLateUpdate()
		{
			NewStaminaMeter.UpdateMeter();
		}
	}
}

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TerminalApi;
using TerminalApi.Classes;
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: AssemblyCompany("AddMoneyMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("My first plugin")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AddMoneyMod")]
[assembly: AssemblyTitle("AddMoneyMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.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 AddMoneyMod
{
	[BepInPlugin("Apoly.AddMoneyMod", "Add Money Mod", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class AddMoneyModBase : BaseUnityPlugin
	{
		private const string mod_GUID = "Apoly.AddMoneyMod";

		private const string mod_NAME = "Add Money Mod";

		private const string mod_VERSION = "1.0.0";

		private readonly Harmony harmony = new Harmony("Apoly.AddMoneyMod");

		private static AddMoneyModBase Instance;

		internal ManualLogSource mls;

		public static string description = "Adds the specified amount of credits";

		private void Awake()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Apoly.AddMoneyMod");
			harmony.PatchAll();
			mls.LogInfo((object)"Plugin Apoly.AddMoneyMod is loaded!");
			CommandInfo val = new CommandInfo();
			val.Category = "none";
			val.Description = description;
			val.DisplayTextSupplier = delegate
			{
				string terminalInput5 = TerminalApi.GetTerminalInput();
				mls.LogInfo((object)(terminalInput5 ?? ""));
				int num5 = 250;
				Terminal val10 = Object.FindObjectOfType<Terminal>();
				val10.groupCredits += num5;
				return "Added 250 credits\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
			};
			TerminalApi.AddCommand("addmoney250", val, (string)null, true);
			CommandInfo val2 = new CommandInfo();
			val2.Category = "none";
			val2.Description = description;
			val2.DisplayTextSupplier = delegate
			{
				string terminalInput4 = TerminalApi.GetTerminalInput();
				mls.LogInfo((object)(terminalInput4 ?? ""));
				int num4 = 500;
				Terminal val9 = Object.FindObjectOfType<Terminal>();
				val9.groupCredits += num4;
				return "Added 500 credits\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
			};
			TerminalApi.AddCommand("addmoney500", val2, (string)null, true);
			CommandInfo val3 = new CommandInfo();
			val3.Category = "none";
			val3.Description = description;
			val3.DisplayTextSupplier = delegate
			{
				string terminalInput3 = TerminalApi.GetTerminalInput();
				mls.LogInfo((object)(terminalInput3 ?? ""));
				int num3 = 750;
				Terminal val8 = Object.FindObjectOfType<Terminal>();
				val8.groupCredits += num3;
				return "Added 750 credits\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
			};
			TerminalApi.AddCommand("addmoney750", val3, (string)null, true);
			CommandInfo val4 = new CommandInfo();
			val4.Category = "none";
			val4.Description = description;
			val4.DisplayTextSupplier = delegate
			{
				string terminalInput2 = TerminalApi.GetTerminalInput();
				mls.LogInfo((object)(terminalInput2 ?? ""));
				int num2 = 1000;
				Terminal val7 = Object.FindObjectOfType<Terminal>();
				val7.groupCredits += num2;
				return "Added 1000 credits\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
			};
			TerminalApi.AddCommand("addmoney1000", val4, (string)null, true);
			CommandInfo val5 = new CommandInfo();
			val5.Category = "none";
			val5.Description = description;
			val5.DisplayTextSupplier = delegate
			{
				string terminalInput = TerminalApi.GetTerminalInput();
				mls.LogInfo((object)(terminalInput ?? ""));
				int num = 5000;
				Terminal val6 = Object.FindObjectOfType<Terminal>();
				val6.groupCredits += num;
				return "Added 5000 credits\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n";
			};
			TerminalApi.AddCommand("addmoney5000", val5, (string)null, true);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "AddMoneyMod";

		public const string PLUGIN_NAME = "AddMoneyMod";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using An0n_Patches.Patches;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using TMPro;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("An0n_Patches")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("An0n_Patches")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("415f18a2-c213-4036-b3f0-7673c0a38c58")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = ".NET Framework 4.6")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace An0n_Patches
{
	[BepInPlugin("com.an0n.patch", "An0n Patch", "1.0.4")]
	public class An0n_Patch_Plugin : BaseUnityPlugin
	{
		private const string pluginGUID = "com.an0n.patch";

		private const string pluginName = "An0n Patch";

		private const string pluginVersion = "1.0.4";

		public static ManualLogSource mls = Logger.CreateLogSource("com.an0n.patch");

		private Harmony harmony = new Harmony("com.an0n.patch");

		public static ConfigEntry<float> instantSprint;

		public static ConfigEntry<float> slipperiness;

		public static ConfigEntry<bool> instantJump;

		public static ConfigEntry<bool> showHPSP;

		private Harmony patcher;

		private void Awake()
		{
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			instantJump = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "instantJump", true, "Enable/disable instant jump. Removes the delay with jumping when enabled.");
			instantSprint = ((BaseUnityPlugin)this).Config.Bind<float>("General", "instantSprint", 2.25f, "How fast to accelerate to sprint value of 2.25. 2.25 is the max, so it's instant acceleration.");
			slipperiness = ((BaseUnityPlugin)this).Config.Bind<float>("General", "slipperiness", 10f, "The amount of slipperiness when running and changing direction. 10-15f is a good value for little to no slippery feeling.");
			showHPSP = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "showHealthStamina", true, "Show your health and sprint/stamina % on the HUD.");
			mls.LogInfo((object)"[An0nPatch] Plugin Loaded");
			patcher = new Harmony("com.an0n.patch");
			patcher.PatchAll(typeof(PlayerControllerPatch));
			patcher.PatchAll(typeof(HUDManagerPatch));
		}
	}
}
namespace An0n_Patches.Patches
{
	[HarmonyPatch]
	internal class HUDManagerPatch : MonoBehaviour
	{
		public static TextMeshProUGUI HPSP_HUDText;

		public static bool instantiating = true;

		[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoadComplete1")]
		[HarmonyPostfix]
		public static void CreateHPSP_HUD()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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)
			if (instantiating)
			{
				GameObject val = GameObject.Find("Systems/UI/Canvas/IngamePlayerHUD/TopLeftCorner/WeightUI");
				GameObject val2 = GameObject.Find("Systems/UI/Canvas/IngamePlayerHUD/TopLeftCorner");
				GameObject val3 = Object.Instantiate<GameObject>(val, val2.transform);
				((Object)val3).name = "HPSP";
				GameObject gameObject = ((Component)val3.transform.GetChild(0)).gameObject;
				RectTransform component = gameObject.GetComponent<RectTransform>();
				component.anchoredPosition = new Vector2(-45f, 10f);
				HPSP_HUDText = gameObject.GetComponent<TextMeshProUGUI>();
				((TMP_Text)HPSP_HUDText).faceColor = Color32.op_Implicit(new Color(255f, 0f, 0f, 255f));
				((TMP_Text)HPSP_HUDText).fontSize = 12f;
				((TMP_Text)HPSP_HUDText).margin = new Vector4(0f, -36f, 100f, 0f);
				((TMP_Text)HPSP_HUDText).alignment = (TextAlignmentOptions)260;
				((TMP_Text)HPSP_HUDText).text = $"{100}\n\n\n{100}%";
				instantiating = false;
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPrefix]
		public static void unInstantiate()
		{
			instantiating = true;
		}

		[HarmonyPatch(typeof(HUDManager), "Update")]
		[HarmonyPostfix]
		public static void Update()
		{
			if (!((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null) && !instantiating)
			{
				float num = Mathf.RoundToInt((float)GameNetworkManager.Instance.localPlayerController.health);
				float num2 = Mathf.RoundToInt((GameNetworkManager.Instance.localPlayerController.sprintMeter * 100f - 10f) / 90f * 100f);
				if (num2 < 0f)
				{
					num2 = 0f;
				}
				if (An0n_Patch_Plugin.showHPSP.Value)
				{
					((TMP_Text)HPSP_HUDText).text = $"{num}\n\n\n\n{num2}%";
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerPatch
	{
		private static PlayerControllerB __mainPlayer;

		public static bool tempcrouch = false;

		private static bool stillInitializing = true;

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static IEnumerable<CodeInstruction> RemoveJumpDelay(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			if (!An0n_Patch_Plugin.instantJump.Value)
			{
				return list;
			}
			int num = 0;
			for (int i = 0; i < list.Count; i++)
			{
				CodeInstruction val = list[i];
				if (!(val.opcode != OpCodes.Newobj))
				{
					ConstructorInfo constructorInfo = val.operand as ConstructorInfo;
					if (((constructorInfo != null) ? constructorInfo.DeclaringType : null) == typeof(WaitForSeconds))
					{
						Debug.Log((object)"[An0nPatch] patched Instant-Jump");
						list[i] = new CodeInstruction(OpCodes.Ldnull, (object)null);
						Debug.Log((object)(num + "-REM:" + ((object)list[i]).ToString()));
						Debug.Log((object)(num - 1 + "REM:" + ((object)list[i - 1]).ToString()));
						list.RemoveAt(i - 1);
						i--;
					}
				}
				num++;
			}
			return list;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		public static IEnumerable<CodeInstruction> fixFloatyTurnAndRun(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			for (int i = 0; i < list.Count - 3; i++)
			{
				CodeInstruction val = list[i];
				if (val.opcode == OpCodes.Ldc_R4 && (float)val.operand == 5f && CodeInstructionExtensions.LoadsField(list[i + 2], typeof(PlayerControllerB).GetField("carryWeight"), false) && list[i + 3].opcode == OpCodes.Ldc_R4 && (float)list[i + 3].operand == 1.5f)
				{
					Debug.Log((object)"[An0nPatch] patched slipperiness");
					list[i] = new CodeInstruction(OpCodes.Ldc_R4, (object)An0n_Patch_Plugin.slipperiness.Value);
				}
			}
			for (int j = 1; j < list.Count - 2; j++)
			{
				CodeInstruction val2 = list[j];
				if (val2.opcode == OpCodes.Ldc_R4 && (float)val2.operand == 2.25f && list[j - 1].opcode == OpCodes.Ldfld && ((object)list[j - 1]).ToString() == "ldfld float GameNetcodeStuff.PlayerControllerB::sprintMultiplier" && list[j + 2].opcode == OpCodes.Ldc_R4 && (float)list[j + 2].operand == 1f)
				{
					Debug.Log((object)"[An0nPatch] patched instant sprint");
					list[j + 2] = new CodeInstruction(OpCodes.Ldc_R4, (object)An0n_Patch_Plugin.instantSprint.Value);
				}
			}
			return list;
		}

		public static bool canJump(RaycastHit ___hit)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			return !Physics.Raycast(((Component)localPlayerController.gameplayCamera).transform.position, Vector3.up, ref ___hit, 0.72f, localPlayerController.playersManager.collidersAndRoomMask, (QueryTriggerInteraction)1);
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		public static void ReadInput(PlayerControllerB __instance, RaycastHit ___hit)
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!stillInitializing)
				{
					if (__mainPlayer == null)
					{
						__mainPlayer = StartOfRound.Instance.localPlayerController;
					}
					PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
					if ((!((NetworkBehaviour)__instance).IsOwner || !__instance.isPlayerControlled || (((NetworkBehaviour)__instance).IsServer && !__instance.isHostPlayerObject)) && !__instance.isTestingPlayer && !__mainPlayer.inTerminalMenu && !__mainPlayer.isTypingChat && !__mainPlayer.isPlayerDead && !__mainPlayer.quickMenuManager.isMenuOpen && !IngamePlayerSettings.Instance.playerInput.actions.FindAction("Crouch", true).IsPressed() && !Physics.Raycast(((Component)localPlayerController.gameplayCamera).transform.position, Vector3.up, ref ___hit, 0.72f, localPlayerController.playersManager.collidersAndRoomMask, (QueryTriggerInteraction)1))
					{
						localPlayerController.isCrouching = false;
						localPlayerController.playerBodyAnimator.SetBool("crouching", false);
					}
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPrefix]
		public static void Jump_performedA(PlayerControllerB __instance, RaycastHit ___hit)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.isCrouching && canJump(___hit))
			{
				__instance.isCrouching = false;
				tempcrouch = true;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPostfix]
		public static void Jump_performedB(PlayerControllerB __instance)
		{
			if (tempcrouch)
			{
				__instance.isCrouching = true;
				tempcrouch = false;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Crouch_performed")]
		[HarmonyPrefix]
		public static void Crouch_performed()
		{
		}

		[HarmonyPatch(typeof(PlayerControllerB), "PlayerHitGroundEffects")]
		[HarmonyPostfix]
		public static void PlayerHitGroundEffects()
		{
			if (GameNetworkManager.Instance.localPlayerController.isCrouching)
			{
				GameNetworkManager.Instance.localPlayerController.playerBodyAnimator.SetTrigger("startCrouching");
				GameNetworkManager.Instance.localPlayerController.playerBodyAnimator.SetBool("crouching", true);
			}
		}

		[HarmonyPatch(typeof(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		public static void Uninitialize()
		{
			stillInitializing = true;
		}

		[HarmonyPatch(typeof(StartOfRound), "SceneManager_OnLoadComplete1")]
		[HarmonyPostfix]
		public static void Initialize()
		{
			stillInitializing = false;
		}
	}
}

using System;
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 BepInEx;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Batteries")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Batteries")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d3aee990-a08c-4376-93d1-e137bd434d45")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Batteries
{
	public class BatteryManager : MonoBehaviour
	{
		public static BatteryManager Instance { get; private set; }

		public InputAction ReloadBatteryAction { get; private set; }

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			ReloadBatteryAction = new InputAction("ReloadBattery", (InputActionType)0, (string)null, (string)null, (string)null, (string)null);
			if (string.IsNullOrEmpty(ConfigManager.useBatteryKeybinds.Value))
			{
				ConfigManager.useBatteryKeybinds.Value = "<Keyboard>/c,<Gamepad>/dpad/up,<XRController>{RightHand}/gripButton";
			}
			string[] array = ConfigManager.useBatteryKeybinds.Value.Split(new char[1] { ',' });
			foreach (string text in array)
			{
				InputActionSetupExtensions.AddBinding(ReloadBatteryAction, text, (string)null, (string)null, (string)null);
			}
			ReloadBatteryAction.Enable();
			ReloadBatteryAction.performed += ReloadBatteryActionPerformed;
		}

		private void OnDestroy()
		{
			ReloadBatteryAction.performed -= ReloadBatteryActionPerformed;
			ReloadBatteryAction.Disable();
		}

		private static void ReloadBatteryActionPerformed(CallbackContext context)
		{
			if (!((CallbackContext)(ref context)).performed)
			{
				return;
			}
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			if ((Object)(object)localPlayerController.currentlyHeldObjectServer == (Object)null || localPlayerController.inSpecialInteractAnimation || !localPlayerController.currentlyHeldObjectServer.itemProperties.requiresBattery || !(localPlayerController.currentlyHeldObjectServer.insertedBattery.charge < 1f))
			{
				return;
			}
			for (int i = 0; i < localPlayerController.ItemSlots.Length; i++)
			{
				if ((Object)(object)localPlayerController.ItemSlots[i] != (Object)null && (localPlayerController.ItemSlots[i].itemProperties.itemId == 5601 || localPlayerController.ItemSlots[i].itemProperties.itemId == 5602))
				{
					((Component)localPlayerController.currentlyHeldObjectServer).GetComponent<AudioSource>().PlayOneShot(BatteriesMod.useBattery);
					localPlayerController.DestroyItemInSlotAndSync(i);
					if (ConfigManager.batteryChargeAmount.Value < 0f || ConfigManager.batteryChargeAmount.Value > 1f)
					{
						Battery insertedBattery = localPlayerController.currentlyHeldObjectServer.insertedBattery;
						insertedBattery.charge += (float)((ConfigEntryBase)ConfigManager.batteryChargeAmount).DefaultValue;
					}
					else
					{
						Battery insertedBattery2 = localPlayerController.currentlyHeldObjectServer.insertedBattery;
						insertedBattery2.charge += ConfigManager.batteryChargeAmount.Value;
					}
					if (localPlayerController.currentlyHeldObjectServer.insertedBattery.charge > 1f)
					{
						localPlayerController.currentlyHeldObjectServer.insertedBattery.charge = 1f;
					}
					if (localPlayerController.currentlyHeldObjectServer.insertedBattery.empty)
					{
						localPlayerController.currentlyHeldObjectServer.insertedBattery.empty = false;
					}
					break;
				}
			}
		}
	}
	internal class ConfigManager
	{
		public const string DEFAULT_KEYBINDS = "<Keyboard>/c,<Gamepad>/dpad/up,<XRController>{RightHand}/gripButton";

		public static ConfigEntry<bool> toolTipEnabled;

		public static ConfigEntry<bool> disableChargingCoil;

		public static ConfigEntry<string> useBatteryKeybinds;

		public static ConfigEntry<float> batteryChargeAmount;

		public static ConfigEntry<int> batteryMaxSpawns;

		public static ConfigEntry<int> batteryRarity;

		public static ConfigEntry<int> batteryScrapValue;

		public static ConfigEntry<int> batteryShopValue;

		public static void Init()
		{
			toolTipEnabled = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<bool>("General Settings", "toolTipEnabled", true, "Allows the mod to add/remove a tool tip to battery powered items when necessary.");
			disableChargingCoil = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<bool>("General Settings", "disableChargingCoil", false, "Disables the charging coil. Mainly for people who wish to have batteries as the only charge source.");
			useBatteryKeybinds = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<string>("General Settings", "useBatteryKeybinds", "<Keyboard>/c,<Gamepad>/dpad/up,<XRController>{RightHand}/gripButton", "The value for the keybinds to use a battery, split by comma. Values for keybinds can be found here: https://docs.unity3d.com/Packages/[email protected]/api/UnityEngine.InputSystem.Key.html.");
			batteryChargeAmount = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<float>("Battery Settings", "batteryChargeAmount", 0.25f, "The amount that batteries charge battery powered items. Can be set to a minimum of 0 (0% charge) and a maximum of 1 (100% charge).");
			batteryMaxSpawns = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<int>("Battery Settings", "batteryMaxSpawns", 10, "The maximum number of batteries that can spawn per moon. Can be set to any number greater than 0.");
			batteryRarity = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<int>("Battery Settings", "batteryRarity", 70, "How rare it is for a battery to spawn. Can be set to a minimum of 0 (cannot spawn) and a maximum of 100 (common).");
			batteryScrapValue = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<int>("Battery Settings", "batteryScrapValue", 5, "The scrap value of batteries.");
			batteryShopValue = ((BaseUnityPlugin)BatteriesMod.instance).Config.Bind<int>("Battery Settings", "batteryShopValue", 0, "How much batteries cost in the shop. When set to 0 or less batteries will not appear in the shop.");
		}
	}
	[BepInPlugin("eXish.Batteries", "Batteries", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class BatteriesMod : BaseUnityPlugin
	{
		private const string mGUID = "eXish.Batteries";

		private const string mName = "Batteries";

		private const string mVersion = "1.1.0";

		private readonly Harmony harmony = new Harmony("eXish.Batteries");

		internal static BatteriesMod instance;

		internal static AssetBundle bundle;

		internal static AudioClip useBattery;

		internal static Item batteryItem;

		private void Awake()
		{
			if ((Object)(object)instance == (Object)null)
			{
				instance = this;
			}
			ConfigManager.Init();
			if (string.IsNullOrEmpty(ConfigManager.useBatteryKeybinds.Value))
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)("The value \"" + ConfigManager.useBatteryKeybinds.Value + "\" is not valid for setting \"useBatteryKeybinds\"! The default will be used instead."));
			}
			if (ConfigManager.batteryChargeAmount.Value < 0f || ConfigManager.batteryChargeAmount.Value > 1f)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)$"The value \"{ConfigManager.batteryChargeAmount.Value}\" is not valid for setting \"batteryChargeAmount\"! The default will be used instead.");
			}
			if (ConfigManager.batteryRarity.Value < 0 || ConfigManager.batteryRarity.Value > 100)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)$"The value \"{ConfigManager.batteryRarity.Value}\" is not valid for setting \"batteryRarity\"! The default will be used instead.");
			}
			if (ConfigManager.batteryMaxSpawns.Value <= 0)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)$"The value \"{ConfigManager.batteryMaxSpawns.Value}\" is not valid for setting \"batteryMaxSpawns\"! The default will be used instead.");
			}
			if (ConfigManager.batteryScrapValue.Value < 0)
			{
				((BaseUnityPlugin)instance).Logger.LogWarning((object)$"The value \"{ConfigManager.batteryScrapValue.Value}\" is not valid for setting \"batteryScrapValue\"! The default will be used instead.");
			}
			string text = ((BaseUnityPlugin)instance).Info.Location.TrimEnd("Batteries.dll".ToCharArray());
			bundle = AssetBundle.LoadFromFile(text + "batteries");
			if ((Object)(object)bundle != (Object)null)
			{
				useBattery = bundle.LoadAsset<AudioClip>("Assets/Batteries/UseBattery.wav");
				batteryItem = bundle.LoadAsset<Item>("Assets/Batteries/Battery.asset");
				if (ConfigManager.batteryRarity.Value != 0)
				{
					Utilities.FixMixerGroups(batteryItem.spawnPrefab);
					NetworkPrefabs.RegisterNetworkPrefab(batteryItem.spawnPrefab);
					Items.RegisterItem(batteryItem);
				}
				if (ConfigManager.batteryShopValue.Value > 0)
				{
					Item val = bundle.LoadAsset<Item>("Assets/Batteries/StoreBattery.asset");
					Utilities.FixMixerGroups(val.spawnPrefab);
					NetworkPrefabs.RegisterNetworkPrefab(val.spawnPrefab);
					TerminalNode val2 = ScriptableObject.CreateInstance<TerminalNode>();
					val2.clearPreviousText = true;
					val2.displayText = "Are you tired of having to travel all the way back to your ship to charge equipment? Well fear not! Durable's new battery line will solve all your charging needs! Get the power you deserve right when you need it!\n\nDurable is not responsible for any injury or death caused by our product. All items purchased are non-refundable.\n\n";
					Items.RegisterShopItem(val, (TerminalNode)null, (TerminalNode)null, val2, ConfigManager.batteryShopValue.Value);
				}
			}
			else
			{
				((BaseUnityPlugin)instance).Logger.LogError((object)"Unable to locate the asset file! Batteries will not spawn or appear in the shop.");
			}
			harmony.PatchAll();
			((BaseUnityPlugin)instance).Logger.LogInfo((object)"Batteries-1.1.0 loaded!");
		}
	}
}
namespace Batteries.Patches
{
	[HarmonyPatch(typeof(GrabbableObject))]
	internal class GrabbableObjectPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void ObjUpdatePatch(ref GrabbableObject __instance)
		{
			if (__instance.itemProperties.itemId == 5601)
			{
				if (ConfigManager.batteryScrapValue.Value < 0)
				{
					__instance.SetScrapValue((int)((ConfigEntryBase)ConfigManager.batteryScrapValue).DefaultValue);
				}
				else
				{
					__instance.SetScrapValue(ConfigManager.batteryScrapValue.Value);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ItemCharger))]
	internal class ItemChargerPatch
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void ChargerUpdatePatch(ref ItemCharger __instance)
		{
			if (((Component)__instance).gameObject.activeSelf && ConfigManager.disableChargingCoil.Value)
			{
				((Component)__instance).gameObject.SetActive(false);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		private static bool wasUsingController;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void PlayerUpdatePatch(ref PlayerControllerB __instance)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			if (!((NetworkBehaviour)__instance).IsOwner || (Object)(object)__instance.currentlyHeldObjectServer == (Object)null || __instance.inSpecialInteractAnimation || !ConfigManager.toolTipEnabled.Value || !__instance.currentlyHeldObjectServer.itemProperties.requiresBattery)
			{
				return;
			}
			if (__instance.currentlyHeldObjectServer.insertedBattery.charge < 1f && (!BatteryTooltipShown() || wasUsingController != StartOfRound.Instance.localPlayerUsingController) && BatteryInInventory())
			{
				InputBinding val = ((IEnumerable<InputBinding>)(object)BatteryManager.Instance.ReloadBatteryAction.bindings).FirstOrDefault((Func<InputBinding, bool>)((InputBinding x) => ((InputBinding)(ref x)).path.ToLowerInvariant().Contains(StartOfRound.Instance.localPlayerUsingController ? "<gamepad>" : "<keyboard>")));
				string text = ((val == default(InputBinding)) ? "?" : ((InputBinding)(ref val)).ToDisplayString((DisplayStringOptions)0, (InputControl)null));
				string[] toolTips = __instance.currentlyHeldObjectServer.itemProperties.toolTips;
				string[] array = new string[toolTips.Length + 1];
				for (int i = 0; i < array.Length; i++)
				{
					if (i != array.Length - 1)
					{
						array[i] = toolTips[i];
					}
					else
					{
						array[i] = "Use Battery : [" + text + "]";
					}
				}
				__instance.currentlyHeldObjectServer.itemProperties.toolTips = array;
				HUDManager.Instance.ClearControlTips();
				__instance.currentlyHeldObjectServer.SetControlTipsForItem();
				wasUsingController = StartOfRound.Instance.localPlayerUsingController;
			}
			if (BatteryTooltipShown() && (__instance.currentlyHeldObjectServer.insertedBattery.charge >= 1f || !BatteryInInventory()))
			{
				__instance.currentlyHeldObjectServer.itemProperties.toolTips = __instance.currentlyHeldObjectServer.itemProperties.toolTips.Where((string x) => !x.StartsWith("Use Battery : [")).ToArray();
				HUDManager.Instance.ClearControlTips();
				__instance.currentlyHeldObjectServer.SetControlTipsForItem();
			}
		}

		private static bool BatteryInInventory()
		{
			return StartOfRound.Instance.localPlayerController.ItemSlots.Any((GrabbableObject x) => Object.op_Implicit((Object)(object)x) && (x.itemProperties.itemId == 5601 || x.itemProperties.itemId == 5602));
		}

		private static bool BatteryTooltipShown()
		{
			return StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer.itemProperties.toolTips.Any((string tooltip) => tooltip.StartsWith("Use Battery : ["));
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		[HarmonyPatch("SpawnScrapInLevel")]
		[HarmonyPostfix]
		private static void SpawnScrapPatch(ref RoundManager __instance)
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			int num = ConfigManager.batteryRarity.Value;
			if (num < 0 || num > 100)
			{
				num = (int)((ConfigEntryBase)ConfigManager.batteryRarity).DefaultValue;
			}
			if (num == 0)
			{
				return;
			}
			int num2 = ConfigManager.batteryMaxSpawns.Value;
			if (num2 <= 0)
			{
				num2 = (int)((ConfigEntryBase)ConfigManager.batteryMaxSpawns).DefaultValue;
			}
			for (int i = 0; i < num2; i++)
			{
				int num3 = __instance.AnomalyRandom.Next(1, 151);
				if (num3 <= num)
				{
					int num4 = __instance.AnomalyRandom.Next(0, __instance.insideAINodes.Length);
					Vector3 randomNavMeshPositionInBoxPredictable = __instance.GetRandomNavMeshPositionInBoxPredictable(__instance.insideAINodes[num4].transform.position, 8f, __instance.navHit, __instance.AnomalyRandom, -1);
					Object.Instantiate<GameObject>(BatteriesMod.batteryItem.spawnPrefab, randomNavMeshPositionInBoxPredictable, Quaternion.identity, __instance.spawnedScrapContainer).GetComponent<NetworkObject>().Spawn(false);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void OnStartOfRoundStart(StartOfRound __instance)
		{
			((Component)__instance).gameObject.AddComponent<BatteryManager>();
		}
	}
}