using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
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("AdditionalSuits")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("AdditionalSuits")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0c25b026-8574-4dd2-9af2-4265f618ef8a")]
[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 AdditionalSuits;

[BepInPlugin("ACS.AdditionalSuits", "AdditionalSuits", "1.0.2")]
public class AdditionalSuitsBase : BaseUnityPlugin
{
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static void StartPatch(ref StartOfRound __instance)
		{
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			try
			{
				if (SuitsLoaded)
				{
					return;
				}
				for (int i = 0; i < __instance.unlockablesList.unlockables.Count; i++)
				{
					UnlockableItem val = __instance.unlockablesList.unlockables[i];
					mls.LogInfo((object)("AdditionalSuits - processing unlockable {index=" + i + ", name=" + val.unlockableName + "}"));
					if (!((Object)(object)val.suitMaterial == (Object)null) && val.alreadyUnlocked)
					{
						string[] files = Directory.GetFiles(SuitTextureFolder, "*.png");
						string[] array = files;
						foreach (string text in array)
						{
							mls.LogInfo((object)("AdditionalSuits - adding suit {file=" + text + "}"));
							UnlockableItem val2 = JsonUtility.FromJson<UnlockableItem>(JsonUtility.ToJson((object)val));
							Material val3 = Object.Instantiate<Material>(val2.suitMaterial);
							Texture2D val4 = new Texture2D(2, 2);
							ImageConversion.LoadImage(val4, File.ReadAllBytes(Path.Combine(SuitTextureFolder, text)));
							val3.mainTexture = (Texture)(object)val4;
							val2.suitMaterial = val3;
							string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
							val2.unlockableName = fileNameWithoutExtension.Replace("_", " ").Substring(2);
							__instance.unlockablesList.unlockables.Add(val2);
						}
						SuitsLoaded = true;
						break;
					}
				}
			}
			catch (Exception ex)
			{
				mls.LogInfo((object)("AdditionalSuits - initialization failed!\nERROR: " + ex));
			}
		}
	}

	private static AdditionalSuitsBase Instance;

	private const string modGUID = "ACS.AdditionalSuits";

	private const string modName = "AdditionalSuits";

	private const string modVersion = "1.0.2";

	private readonly Harmony harmony = new Harmony("ACS.AdditionalSuits");

	public static ManualLogSource mls;

	public static bool SuitsLoaded;

	public static string SuitTextureFolder;

	private void Awake()
	{
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		mls = Logger.CreateLogSource("ACS.AdditionalSuits");
		mls.LogInfo((object)"AdditionalSuits - initializing...");
		SuitTextureFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "resAdditionalSuits");
		harmony.PatchAll();
		mls.LogInfo((object)"AdditionalSuits - initialized!");
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LCAlwaysHearWalkieMod.Patches;
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: AssemblyCompany("AlwaysHearWalkie")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.4.2.0")]
[assembly: AssemblyInformationalVersion("1.4.2+4173bc4d88b293dfbed3e97cfc3a082065ce4da9")]
[assembly: AssemblyProduct("Always Hear Active Walkies")]
[assembly: AssemblyTitle("AlwaysHearWalkie")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.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 BepInEx5.PluginTemplate
{
	[BepInPlugin("suskitech.LCAlwaysHearActiveWalkie", "LC Always Hear Active Walkies", "1.4.2")]
	public class LCAlwaysHearWalkieMod : BaseUnityPlugin
	{
		public static ManualLogSource Log;

		private const string modGUID = "suskitech.LCAlwaysHearActiveWalkie";

		private const string modName = "LC Always Hear Active Walkies";

		private const string modVersion = "1.4.2";

		private readonly Harmony harmony = new Harmony("suskitech.LCAlwaysHearActiveWalkie");

		private static LCAlwaysHearWalkieMod Instance;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			Log = Logger.CreateLogSource("suskitech.LCAlwaysHearActiveWalkie");
			Log.LogInfo((object)"\\ /");
			Log.LogInfo((object)"/|\\");
			Log.LogInfo((object)" |----|");
			Log.LogInfo((object)" |[__]| Always Hear Active Walkies");
			Log.LogInfo((object)" |.  .| Version 1.4.2 Loaded");
			Log.LogInfo((object)" |____|");
			harmony.PatchAll(typeof(LCAlwaysHearWalkieMod));
			harmony.PatchAll(typeof(PlayerControllerBPatch));
			harmony.PatchAll(typeof(WalkieTalkiePatch));
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "AlwaysHearWalkie";

		public const string PLUGIN_NAME = "Always Hear Active Walkies";

		public const string PLUGIN_VERSION = "1.4.2";
	}
}
namespace LCAlwaysHearWalkieMod.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		private static float AudibleDistance = 20f;

		private static float throttleInterval = 0.4f;

		private static float throttle = 0f;

		private static float AverageDistanceToHeldWalkie = 2f;

		private static float WalkieRecordingRange = 20f;

		private static float PlayerToPlayerSpatialHearingRange = 20f;

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void alwaysHearWalkieTalkiesPatch(ref bool ___holdingWalkieTalkie, ref PlayerControllerB __instance)
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0371: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			throttle += Time.deltaTime;
			if (throttle < throttleInterval)
			{
				return;
			}
			throttle = 0f;
			if ((Object)(object)__instance == (Object)null || (Object)(object)GameNetworkManager.Instance == (Object)null || (Object)(object)__instance != (Object)(object)GameNetworkManager.Instance.localPlayerController || (Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null || GameNetworkManager.Instance.localPlayerController.isPlayerDead)
			{
				return;
			}
			List<WalkieTalkie> list = new List<WalkieTalkie>();
			List<WalkieTalkie> list2 = new List<WalkieTalkie>();
			for (int i = 0; i < WalkieTalkie.allWalkieTalkies.Count; i++)
			{
				float num = Vector3.Distance(((Component)WalkieTalkie.allWalkieTalkies[i]).transform.position, ((Component)__instance).transform.position);
				if (num <= AudibleDistance)
				{
					if (((GrabbableObject)WalkieTalkie.allWalkieTalkies[i]).isBeingUsed)
					{
						list.Add(WalkieTalkie.allWalkieTalkies[i]);
					}
				}
				else
				{
					list2.Add(WalkieTalkie.allWalkieTalkies[i]);
				}
			}
			bool flag = list.Count > 0;
			if (flag != __instance.holdingWalkieTalkie)
			{
				___holdingWalkieTalkie = flag;
				for (int j = 0; j < list2.Count; j++)
				{
					if (j < list.Count)
					{
						list2[j].thisAudio.Stop();
					}
				}
			}
			if (!flag)
			{
				return;
			}
			PlayerControllerB val = ((!GameNetworkManager.Instance.localPlayerController.isPlayerDead || !((Object)(object)GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript != (Object)null)) ? GameNetworkManager.Instance.localPlayerController : GameNetworkManager.Instance.localPlayerController.spectatedPlayerScript);
			for (int k = 0; k < StartOfRound.Instance.allPlayerScripts.Length; k++)
			{
				if ((!StartOfRound.Instance.allPlayerScripts[k].isPlayerControlled && !StartOfRound.Instance.allPlayerScripts[k].isPlayerDead) || (Object)(object)StartOfRound.Instance.allPlayerScripts[k] == (Object)(object)GameNetworkManager.Instance.localPlayerController || StartOfRound.Instance.allPlayerScripts[k].isPlayerDead)
				{
					continue;
				}
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[k];
				if (!val2.holdingWalkieTalkie)
				{
					continue;
				}
				float num2 = Vector3.Distance(((Component)val).transform.position, ((Component)val2).transform.position);
				float num3 = float.MaxValue;
				float num4 = float.MaxValue;
				for (int l = 0; l < WalkieTalkie.allWalkieTalkies.Count; l++)
				{
					if (!((GrabbableObject)WalkieTalkie.allWalkieTalkies[l]).isBeingUsed)
					{
						continue;
					}
					float num5 = Vector3.Distance(((Component)WalkieTalkie.allWalkieTalkies[l].target).transform.position, ((Component)val).transform.position);
					if (num5 < num4)
					{
						num4 = num5;
					}
					if (!WalkieTalkie.allWalkieTalkies[l].speakingIntoWalkieTalkie)
					{
						float num6 = Vector3.Distance(((Component)WalkieTalkie.allWalkieTalkies[l]).transform.position, ((Component)val2).transform.position);
						if (num6 < num3)
						{
							num3 = num6;
						}
					}
				}
				float num7 = Mathf.Min(1f - Mathf.InverseLerp(AverageDistanceToHeldWalkie, WalkieRecordingRange, num3), 1f - Mathf.InverseLerp(AverageDistanceToHeldWalkie, WalkieRecordingRange, num4));
				float num8 = 1f - Mathf.InverseLerp(0f, PlayerToPlayerSpatialHearingRange, num2);
				val2.voicePlayerState.Volume = Mathf.Max(num7, num8);
			}
		}
	}
	[HarmonyPatch(typeof(WalkieTalkie))]
	internal class WalkieTalkiePatch
	{
		[HarmonyPatch("EnableWalkieTalkieListening")]
		[HarmonyPrefix]
		private static bool alwaysHearWalkieTalkiesEnableWalkieTalkieListeningPatch(bool enable)
		{
			if (!enable)
			{
				return false;
			}
			return true;
		}
	}
}

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;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;

[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.2")]
	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.2";

		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;

		private static bool initializing = true;

		private static bool up = false;

		public static bool tempcrouch = false;

		[HarmonyTranspiler]
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static IEnumerable<CodeInstruction> RemoveJumpDelay(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			if (!An0n_Patch_Plugin.instantJump.Value)
			{
				return list;
			}
			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);
						list.RemoveAt(i - 1);
						i--;
					}
				}
			}
			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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!initializing)
				{
					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 && !((ButtonControl)Keyboard.current.leftCtrlKey).isPressed && localPlayerController.playerBodyAnimator.GetBool("crouching") && !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(GameNetworkManager), "Disconnect")]
		[HarmonyPostfix]
		public static void Uninitialize()
		{
			__mainPlayer = null;
			initializing = true;
		}

		[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(StartOfRound), "SceneManager_OnLoadComplete1")]
		[HarmonyPostfix]
		public static void Initialize()
		{
			initializing = false;
		}
	}
}

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 BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using TMPro;
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("BetterItemScan")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterItemScan")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("04cd6816-7aba-4c14-a9a7-bf328df25692")]
[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 BetterItemScan
{
	[BepInPlugin("PopleZoo.BetterItemScan", "Better Item Scan", "2.0.0.0")]
	public class BetterItemScanModBase : BaseUnityPlugin
	{
		private const string modGUID = "PopleZoo.BetterItemScan";

		private const string modName = "Better Item Scan";

		private const string modVersion = "2.0.0.0";

		private readonly Harmony harmony = new Harmony("PopleZoo.BetterItemScan");

		public static BetterItemScanModBase Instance;

		public ManualLogSource mls;

		public static ConfigEntry<float> ItemScanRadius;

		public static ConfigEntry<float> AdjustScreenPositionXaxis;

		public static ConfigEntry<float> AdjustScreenPositionYaxis;

		public static ConfigEntry<float> ItemScaningUICooldown;

		public static ConfigEntry<bool> ShowDebugMode;

		public static ConfigEntry<bool> ShowShipTotalOnShipOnly;

		public static ConfigEntry<bool> ShowTotalOnShipOnly;

		public static ConfigEntry<bool> CalculateForQuota;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("PopleZoo.BetterItemScan");
			mls.LogInfo((object)"Plugin BetterItemScan is loaded!");
			LoadConfigs();
			harmony.PatchAll();
		}

		private void LoadConfigs()
		{
			ShowDebugMode = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowDebugMode", false, "Shows the change in width of the area to scan");
			ShowShipTotalOnShipOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowShipTotalOnShipOnly", false, "Whether or not to show the ship's total only in the ship");
			ShowTotalOnShipOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "ShowTotalOnShipOnly", false, "Whether or not to show the total scanned in the ship only");
			CalculateForQuota = ((BaseUnityPlugin)this).Config.Bind<bool>("Settings", "CalculateForQuota", true, "Whether or not to calculate scanned items to see which meet the quota and if any do");
			ItemScanRadius = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "ItemScanRadius", 20f, "The default width is 20");
			ItemScaningUICooldown = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "ItemScaningUICooldown", 3f, "The default value is 5f, how long the ui stays on screen");
			AdjustScreenPositionXaxis = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "AdjustScreenPositionXaxis", 0f, "The default value is 0, you will add or take away from its original position");
			AdjustScreenPositionYaxis = ((BaseUnityPlugin)this).Config.Bind<float>("Settings", "AdjustScreenPositionYaxis", 0f, "The default value is 0, you will add or take away from its original position");
		}
	}
}
namespace BetterItemScan.Patches
{
	[HarmonyPatch]
	internal class HudManagerPatch_UI
	{
		private static GameObject _totalCounter;

		private static TextMeshProUGUI _textMesh;

		private static float _displayTimeLeft = BetterItemScanModBase.ItemScaningUICooldown.Value;

		private static float Totalsum;

		private static float Totalship;

		public static List<ScanNodeProperties> scannedNodeObjects = new List<ScanNodeProperties>();

		public static List<string> meetQuotaItemNames = new List<string>();

		public static Dictionary<ScanNodeProperties, int> ItemsDictionary = new Dictionary<ScanNodeProperties, int>();

		public static int MeetQuota(List<int> items, int quota)
		{
			items = items.Where((int item) => item >= quota).ToList();
			if (!items.Any())
			{
				return -1;
			}
			return items.Aggregate((int a, int b) => (Math.Abs(quota - a) < Math.Abs(quota - b)) ? a : b);
		}

		public static List<List<int>> FindCombinations(List<int> items, int quota)
		{
			List<List<int>> list = new List<List<int>>();
			int count = items.Count;
			int num = int.MaxValue;
			for (int i = 0; i < 1 << count; i++)
			{
				List<int> list2 = new List<int>();
				for (int j = 0; j < count; j++)
				{
					if ((i & (1 << j)) > 0)
					{
						list2.Add(items[j]);
					}
				}
				int num2 = list2.Sum();
				int num3 = Math.Abs(quota - num2);
				if (num3 < num)
				{
					num = num3;
					list.Clear();
					list.Add(list2);
				}
				else if (num3 == num)
				{
					list.Add(list2);
				}
			}
			list.Sort((List<int> a, List<int> b) => a.Count.CompareTo(b.Count));
			return list;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "PingScan_performed")]
		private static void OnScan(HUDManager __instance, CallbackContext context)
		{
			FieldInfo field = typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.NonPublic);
			float num = (float)field.GetValue(__instance);
			MethodInfo method = typeof(HUDManager).GetMethod("CanPlayerScan", BindingFlags.Instance | BindingFlags.NonPublic);
			if ((Object)(object)GameNetworkManager.Instance.localPlayerController == (Object)null || !((CallbackContext)(ref context)).performed || !(bool)method.Invoke(__instance, null) || (double)num > -1.0)
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)_totalCounter))
			{
				CopyValueCounter();
			}
			List<ScanNodeProperties> list = CalculateLootItems();
			meetQuotaItemNames.Clear();
			foreach (ScanNodeProperties item in list)
			{
				ItemsDictionary.Add(item, item.scrapValue);
			}
			int profitQuota = TimeOfDay.Instance.profitQuota;
			List<int> list2 = ItemsDictionary.Values.ToList();
			list2.Sort();
			list2.Reverse();
			int bestIndividualItem = MeetQuota(list2, profitQuota);
			List<List<int>> list3 = FindCombinations(list2, profitQuota);
			foreach (List<int> item2 in list3)
			{
				Debug.Log((object)string.Join(", ", item2));
			}
			if (bestIndividualItem != -1 && list3.Any())
			{
				int num2 = list3.First().Sum();
				int selectedValue = -1;
				if (Math.Abs(profitQuota - bestIndividualItem) <= Math.Abs(profitQuota - num2))
				{
					selectedValue = bestIndividualItem;
				}
				else if (list3.Any())
				{
					selectedValue = list3.First().First();
				}
				if (selectedValue != -1)
				{
					ScanNodeProperties key = ItemsDictionary.FirstOrDefault((KeyValuePair<ScanNodeProperties, int> x) => x.Value == selectedValue).Key;
					if ((Object)(object)key != (Object)null)
					{
						meetQuotaItemNames.Add(key.headerText);
					}
				}
			}
			else if (bestIndividualItem != -1)
			{
				ScanNodeProperties key2 = ItemsDictionary.FirstOrDefault((KeyValuePair<ScanNodeProperties, int> x) => x.Value == bestIndividualItem).Key;
				if ((Object)(object)key2 != (Object)null)
				{
					meetQuotaItemNames.Add(key2.headerText);
				}
			}
			ItemsDictionary.Clear();
			string text = "";
			foreach (ScanNodeProperties item3 in list)
			{
				string text2 = $"{item3.headerText}: ${item3.scrapValue}";
				if (!BetterItemScanModBase.CalculateForQuota.Value && meetQuotaItemNames.Contains(item3.headerText))
				{
					meetQuotaItemNames.Remove(item3.headerText);
					text2 = "* " + text2;
				}
				text = text + text2 + "\n";
			}
			((TMP_Text)_textMesh).text = text;
			if (BetterItemScanModBase.ShowShipTotalOnShipOnly.Value)
			{
				if (!GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
				{
					TextMeshProUGUI textMesh = _textMesh;
					((TMP_Text)textMesh).text = ((TMP_Text)textMesh).text + "\nTotal Scanned: " + Totalsum;
				}
				else
				{
					TextMeshProUGUI textMesh2 = _textMesh;
					((TMP_Text)textMesh2).text = ((TMP_Text)textMesh2).text + "\nTotal Scanned: " + Totalsum + " Ship Total: " + Totalship;
				}
			}
			else
			{
				TextMeshProUGUI textMesh2 = _textMesh;
				((TMP_Text)textMesh2).text = ((TMP_Text)textMesh2).text + "\nTotal Scanned: " + Totalsum + " Ship Total: " + Totalship;
			}
			if (BetterItemScanModBase.ShowTotalOnShipOnly.Value)
			{
				if (!GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom)
				{
					((Component)_textMesh).gameObject.SetActive(false);
					((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(true);
				}
				else
				{
					((Component)_textMesh).gameObject.SetActive(true);
					((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(false);
				}
			}
			_displayTimeLeft = BetterItemScanModBase.ItemScaningUICooldown.Value;
			if (!_totalCounter.activeSelf)
			{
				((MonoBehaviour)GameNetworkManager.Instance).StartCoroutine(ValueCoroutine());
			}
		}

		private static List<ScanNodeProperties> CalculateLootItems()
		{
			List<GrabbableObject> source = (from obj in GameObject.Find("/Environment/HangarShip").GetComponentsInChildren<GrabbableObject>()
				where ((Object)obj).name != "ClipboardManual" && ((Object)obj).name != "StickyNoteItem"
				select obj).ToList();
			List<ScanNodeProperties> list = scannedNodeObjects.Where((ScanNodeProperties obj) => obj.headerText != "ClipboardManual" && obj.headerText != "StickyNoteItem" && obj.scrapValue != 0).ToList();
			Totalsum = list.Sum((ScanNodeProperties scrap) => scrap.scrapValue);
			Totalship = source.Sum((GrabbableObject scrap) => scrap.scrapValue);
			return list;
		}

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

		private static void CopyValueCounter()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: 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))
			{
				BetterItemScanModBase.Instance.mls.LogError((object)"Failed to find ValueCounter object to copy!");
			}
			_totalCounter = Object.Instantiate<GameObject>(val.gameObject, val.transform.parent, false);
			Vector3 localPosition = _totalCounter.transform.localPosition;
			float num = Mathf.Clamp(localPosition.x + BetterItemScanModBase.AdjustScreenPositionXaxis.Value + 50f, -6000f, (float)Screen.width);
			float num2 = Mathf.Clamp(localPosition.y + BetterItemScanModBase.AdjustScreenPositionYaxis.Value - 80f, -6000f, (float)Screen.height);
			_totalCounter.transform.localPosition = new Vector3(num, num2, localPosition.z);
			_textMesh = _totalCounter.GetComponentInChildren<TextMeshProUGUI>();
			((TMP_Text)_textMesh).alignment = (TextAlignmentOptions)1025;
			RectTransform rectTransform = ((TMP_Text)_textMesh).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 2f);
			rectTransform.anchorMax = new Vector2(0.5f, 2f);
			rectTransform.pivot = new Vector2(0.5f, 0f);
			Vector3 localPosition2 = ((Transform)rectTransform).localPosition;
			((Transform)rectTransform).localPosition = new Vector3(localPosition2.x, localPosition2.y - 140f, localPosition2.z);
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_A
	{
		private static LineRenderer lineRenderer;

		private static GameObject lineObject;

		private static float maxDistance = 80f;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "AssignNewNodes")]
		private static bool AssignNewNodes_patch(HUDManager __instance, PlayerControllerB playerScript)
		{
			//IL_00e2: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			HudManagerPatch_UI.scannedNodeObjects.Clear();
			if ((Object)(object)lineRenderer == (Object)null)
			{
				lineObject = new GameObject("LineObject");
				lineRenderer = lineObject.AddComponent<LineRenderer>();
				lineRenderer.positionCount = 2;
				lineObject.SetActive(false);
			}
			FieldInfo field = typeof(HUDManager).GetField("nodesOnScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			List<ScanNodeProperties> list = field.GetValue(__instance) as List<ScanNodeProperties>;
			FieldInfo field2 = typeof(HUDManager).GetField("scannedScrapNum", BindingFlags.Instance | BindingFlags.NonPublic);
			object value = field2.GetValue(__instance);
			FieldInfo field3 = typeof(HUDManager).GetField("scanNodesHit", BindingFlags.Instance | BindingFlags.NonPublic);
			RaycastHit[] array = field3.GetValue(__instance) as RaycastHit[];
			MethodInfo method = typeof(HUDManager).GetMethod("AttemptScanNode", BindingFlags.Instance | BindingFlags.NonPublic);
			int num = Physics.SphereCastNonAlloc(new Ray(((Component)playerScript.gameplayCamera).transform.position + ((Component)playerScript.gameplayCamera).transform.forward * 20f, ((Component)playerScript.gameplayCamera).transform.forward), BetterItemScanModBase.ItemScanRadius.Value, array, maxDistance, 4194304);
			Vector3 val = new Vector3(((Component)playerScript.gameplayCamera).transform.position.x, ((Component)playerScript.gameplayCamera).transform.position.y - 2f, ((Component)playerScript.gameplayCamera).transform.position.z) + ((Component)playerScript.gameplayCamera).transform.forward;
			Vector3 forward = ((Component)playerScript.gameplayCamera).transform.forward;
			if (BetterItemScanModBase.ShowDebugMode.Value)
			{
				lineObject.SetActive(true);
				lineRenderer.SetPosition(0, val);
				lineRenderer.SetPosition(1, val + forward * maxDistance);
				LineRenderer obj = lineRenderer;
				float startWidth = (lineRenderer.endWidth = BetterItemScanModBase.ItemScanRadius.Value);
				obj.startWidth = startWidth;
			}
			if (num > __instance.scanElements.Length)
			{
				num = __instance.scanElements.Length;
			}
			list.Clear();
			value = 0;
			if (num > __instance.scanElements.Length)
			{
				for (int i = 0; i < num; i++)
				{
					ScanNodeProperties component = ((Component)((RaycastHit)(ref array[i])).transform).gameObject.GetComponent<ScanNodeProperties>();
					HudManagerPatch_UI.scannedNodeObjects.Add(component);
					if (component.nodeType == 1 || component.nodeType == 2)
					{
						object[] parameters = new object[3] { component, i, playerScript };
						method.Invoke(__instance, parameters);
					}
				}
			}
			if (list.Count < __instance.scanElements.Length)
			{
				for (int j = 0; j < num; j++)
				{
					ScanNodeProperties component2 = ((Component)((RaycastHit)(ref array[j])).transform).gameObject.GetComponent<ScanNodeProperties>();
					object[] parameters2 = new object[3] { component2, j, playerScript };
					method.Invoke(__instance, parameters2);
				}
			}
			return false;
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_B
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(HUDManager), "AttemptScanNode")]
		private static bool AttemptScanNode_patch(HUDManager __instance, ScanNodeProperties node, int i, PlayerControllerB playerScript)
		{
			MethodInfo method = typeof(HUDManager).GetMethod("MeetsScanNodeRequirements", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method2 = typeof(HUDManager).GetMethod("AssignNodeToUIElement", BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field = typeof(HUDManager).GetField("nodesOnScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			List<ScanNodeProperties> list = field.GetValue(__instance) as List<ScanNodeProperties>;
			FieldInfo field2 = typeof(HUDManager).GetField("scannedScrapNum", BindingFlags.Instance | BindingFlags.NonPublic);
			int num = (int)field2.GetValue(__instance);
			FieldInfo field3 = typeof(HUDManager).GetField("playerPingingScan", BindingFlags.Instance | BindingFlags.NonPublic);
			float num2 = (float)field3.GetValue(__instance);
			object[] parameters = new object[2] { node, playerScript };
			object[] parameters2 = new object[1] { node };
			if (!(bool)method.Invoke(__instance, parameters))
			{
				return false;
			}
			if (node.nodeType == 2)
			{
				num++;
			}
			if (!list.Contains(node))
			{
				list.Add(node);
			}
			if (node.creatureScanID == -1)
			{
				HudManagerPatch_UI.scannedNodeObjects.Add(node);
			}
			if ((double)num2 < 0.0)
			{
				return false;
			}
			method2.Invoke(__instance, parameters2);
			return false;
		}
	}
	[HarmonyPatch]
	public class PlayerControllerBPatch_C
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(HUDManager), "Update")]
		private static void Update_patch(HUDManager __instance)
		{
			FieldInfo field = typeof(HUDManager).GetField("addingToDisplayTotal", BindingFlags.Instance | BindingFlags.NonPublic);
			object value = field.GetValue(__instance);
			((Component)((TMP_Text)__instance.totalValueText).transform.parent).gameObject.SetActive(false);
			value = false;
		}
	}
}