using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using HarmonyLib;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("AlwaysPickup")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AlwaysPickup")]
[assembly: AssemblyTitle("AlwaysPickup")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace AlwaysPickup;

[BepInPlugin("NutNutty.AlwaysPickup", "Always Pickup", "1.0.0")]
public class AlwaysPickup : BaseUnityPlugin
{
	public void Awake()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		new Harmony("AlwaysPickup").PatchAll();
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Always Pickup plugin loaded!");
	}
}
[HarmonyPatch(typeof(GrabbableObject))]
public class GrabbableObjectPatch
{
	[HarmonyTranspiler]
	[HarmonyPatch("Start")]
	private static IEnumerable<CodeInstruction> TranspileGrabbableObject(IEnumerable<CodeInstruction> instructions)
	{
		//IL_0003: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Expected O, but got Unknown
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0048: Expected O, but got Unknown
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Expected O, but got Unknown
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Expected O, but got Unknown
		return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, Array.Empty<CodeMatch>()).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
		{
			new CodeInstruction(OpCodes.Ldarg_0, (object)null),
			new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(GrabbableObject), "itemProperties")),
			new CodeInstruction(OpCodes.Ldc_I4_1, (object)null),
			new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(Item), "canBeGrabbedBeforeGameStart"))
		}).InstructionEnumeration();
	}
}

using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using GameNetcodeStuff;
using HarmonyLib;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BetterClock")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterClock")]
[assembly: AssemblyCopyright("Copyright © BlueAmulet 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("de27b4d1-820d-4505-a953-6001420281e4")]
[assembly: AssemblyFileVersion("1.0.3")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.3.0")]
namespace BetterClock
{
	[BepInPlugin("BlueAmulet.BetterClock", "BetterClock", "1.0.3")]
	public class BetterClock : BaseUnityPlugin
	{
		internal const string Name = "BetterClock";

		internal const string Author = "BlueAmulet";

		internal const string ID = "BlueAmulet.BetterClock";

		internal const string Version = "1.0.3";

		public void Awake()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			Settings.InitConfig(((BaseUnityPlugin)this).Config);
			Harmony val = new Harmony("BlueAmulet.BetterClock");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Applying Harmony patches");
			val.PatchAll(Assembly.GetExecutingAssembly());
			int num = 0;
			foreach (MethodBase patchedMethod in val.GetPatchedMethods())
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched " + patchedMethod.DeclaringType.Name + "." + patchedMethod.Name));
				num++;
			}
			((BaseUnityPlugin)this).Logger.LogInfo((object)(num + " patches applied"));
		}
	}
	internal static class Settings
	{
		internal static ConfigEntry<bool> compact;

		internal static ConfigEntry<bool> leadingZero;

		internal static ConfigEntry<bool> darkZero;

		internal static ConfigEntry<bool> fasterUpdate;

		internal static ConfigEntry<bool> raiseClock;

		internal static ConfigEntry<bool> hours24;

		internal static ConfigEntry<bool> properTime;

		internal static ConfigEntry<float> visibilityShip;

		internal static ConfigEntry<float> visibilityOutside;

		internal static ConfigEntry<float> visibilityInside;

		internal static ConfigEntry<float> visibilityOverride;

		internal static ConfigEntry<KeyboardShortcut> overrideKeybind;

		internal static ConfigEntry<bool> overrideToggle;

		public static void InitConfig(ConfigFile config)
		{
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			compact = config.Bind<bool>("Clock", "CompactClock", true, "Makes the clock more compact");
			leadingZero = config.Bind<bool>("Clock", "LeadingZero", true, "Adds a leading zero to hours before 10");
			darkZero = config.Bind<bool>("Clock", "DarkZero", true, "Leading zeros are dark");
			fasterUpdate = config.Bind<bool>("Clock", "FasterUpdate", true, "Update the clock more often");
			raiseClock = config.Bind<bool>("Clock", "RaiseClock", true, "Raise the clock near the top of the screen");
			hours24 = config.Bind<bool>("Clock", "24Hours", false, "Use 24 hour time");
			properTime = config.Bind<bool>("Clock", "ProperTime", true, "Fix time formatting caused by the game or other mods");
			visibilityShip = config.Bind<float>("Clock", "VisibilityShip", 1f, "Visibility of clock inside ship");
			visibilityOutside = config.Bind<float>("Clock", "VisibilityOutside", 1f, "Visibility of clock outside");
			visibilityInside = config.Bind<float>("Clock", "VisibilityInside", 0.25f, "Visibility of clock inside factory");
			visibilityOverride = config.Bind<float>("Clock", "VisibilityOverride", 1f, "Visibility when using override keybind");
			overrideKeybind = config.Bind<KeyboardShortcut>("Clock", "OverrideKeybind", KeyboardShortcut.Empty, "Keybind to trigger visibility override");
			overrideToggle = config.Bind<bool>("Clock", "OverrideToggle", false, "Switch the override keybind between toggle or hold");
		}
	}
}
namespace BetterClock.Patches
{
	[HarmonyPatch(typeof(HUDManager))]
	internal static class ClockPatch
	{
		private static int lastTime = -1;

		private static bool overrideDisplay = false;

		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		public static void PostfixAwake(ref HUDManager __instance)
		{
			//IL_00a0: 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_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (!Settings.compact.Value)
			{
				return;
			}
			Transform parent = ((TMP_Text)__instance.clockNumber).transform.parent;
			if (Settings.raiseClock.Value)
			{
				Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
				if (pluginInfos.ContainsKey("SolosRingCompass") || pluginInfos.ContainsKey("LineCompassPlugin"))
				{
					parent.localPosition += new Vector3(0f, 20f, 0f);
				}
				else
				{
					parent.localPosition += new Vector3(0f, 40f, 0f);
				}
			}
			RectTransform component = ((Component)parent).GetComponent<RectTransform>();
			component.sizeDelta = new Vector2(component.sizeDelta.x, 50f);
			((TMP_Text)__instance.clockNumber).enableWordWrapping = false;
			RectTransform component2 = ((Component)__instance.clockIcon).GetComponent<RectTransform>();
			component2.sizeDelta *= 0.6f;
			if (!Settings.hours24.Value)
			{
				Transform transform = ((TMP_Text)__instance.clockNumber).transform;
				transform.localPosition += new Vector3(10f, -1f, 0f);
				Transform transform2 = ((Component)__instance.clockIcon).transform;
				transform2.localPosition += new Vector3(-25f, -2f, 0f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("SetClockVisible")]
		public static bool PrefixVisible(ref HUDManager __instance)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			KeyboardShortcut value = Settings.overrideKeybind.Value;
			if (Settings.overrideToggle.Value)
			{
				if (((KeyboardShortcut)(ref value)).IsDown())
				{
					overrideDisplay = !overrideDisplay;
				}
			}
			else
			{
				overrideDisplay = ((KeyboardShortcut)(ref value)).IsPressed();
			}
			if (overrideDisplay)
			{
				__instance.Clock.targetAlpha = Settings.visibilityOverride.Value;
				return false;
			}
			GameNetworkManager instance = GameNetworkManager.Instance;
			PlayerControllerB val = null;
			if ((Object)(object)instance != (Object)null)
			{
				val = instance.localPlayerController;
			}
			if ((Object)(object)val != (Object)null)
			{
				if (val.isInHangarShipRoom)
				{
					__instance.Clock.targetAlpha = Settings.visibilityShip.Value;
				}
				else if (val.isInsideFactory)
				{
					__instance.Clock.targetAlpha = Settings.visibilityInside.Value;
				}
				else
				{
					__instance.Clock.targetAlpha = Settings.visibilityOutside.Value;
				}
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetClock")]
		public static void PostfixSetClock(ref HUDManager __instance, ref float timeNormalized, ref float numberOfHours)
		{
			int num = (int)(timeNormalized * (60f * numberOfHours)) + 360;
			int num2 = num / 60 % 24;
			int num3 = num % 60;
			string text = ((!Settings.hours24.Value) ? ((TMP_Text)__instance.clockNumber).text : $"{num2}:{num3:00}");
			if (Settings.properTime.Value)
			{
				if (text.Length >= 3 && text[0] == '0' && text[2] == ':')
				{
					text = text.Substring(1);
				}
				else if (text.StartsWith("24:"))
				{
					text = "0:" + text.Substring(3);
				}
				if (text.StartsWith("0:") && text.EndsWith("M"))
				{
					text = "12:" + text.Substring(2);
				}
				if (num2 < 12 && text.EndsWith("PM"))
				{
					text = text.Substring(0, text.Length - 2) + "AM";
				}
				else if (num2 >= 12 && text.EndsWith("AM"))
				{
					text = text.Substring(0, text.Length - 2) + "PM";
				}
			}
			if (Settings.compact.Value)
			{
				text = text.Replace('\n', ' ').Replace("   ", " ");
			}
			if (Settings.leadingZero.Value && (text.Length <= 4 || text.Length == 7))
			{
				text = ((!Settings.darkZero.Value) ? ("0" + text) : ("<color=#602000>0</color>" + text));
			}
			((TMP_Text)__instance.clockNumber).text = text;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(TimeOfDay))]
		[HarmonyPatch("MoveTimeOfDay")]
		public static void PostfixMoveTimeOfDay(ref TimeOfDay __instance, ref float ___changeHUDTimeInterval)
		{
			if (Settings.fasterUpdate.Value)
			{
				int num = (int)(__instance.normalizedTimeOfDay * (60f * (float)__instance.numberOfHours));
				if (num != lastTime)
				{
					lastTime = num;
					HUDManager.Instance.SetClock(__instance.normalizedTimeOfDay, (float)__instance.numberOfHours, true);
					___changeHUDTimeInterval = 0f;
				}
			}
		}
	}
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BetterStamina.Config;
using GameNetcodeStuff;
using HarmonyLib;
using Unity.Collections;
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("BetterStamina")]
[assembly: AssemblyDescription("Mod made by flipf17")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BetterStamina")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1c42022e-b386-4342-baf0-67de1b7529e2")]
[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 BetterStamina
{
	[BepInPlugin("FlipMods.BetterStamina", "BetterStamina", "1.3.2")]
	public class Plugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		public static Plugin instance;

		private void Awake()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			instance = this;
			ConfigSettings.BindConfigSettings();
			_harmony = new Harmony("BetterStamina");
			_harmony.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"BetterStamina loaded");
		}

		public static void Log(string message)
		{
			((BaseUnityPlugin)instance).Logger.LogInfo((object)message);
		}

		public static void LogError(string message)
		{
			((BaseUnityPlugin)instance).Logger.LogError((object)message);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "FlipMods.BetterStamina";

		public const string PLUGIN_NAME = "BetterStamina";

		public const string PLUGIN_VERSION = "1.3.2";
	}
}
namespace BetterStamina.Patches
{
	[HarmonyPatch]
	public class PlayerPatcher
	{
		private static float currentSprintMeter;

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPrefix]
		public static void UpdateStaminaPrefix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				currentSprintMeter = __instance.sprintMeter;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyPostfix]
		public static void UpdateStaminaPostfix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				float num = __instance.sprintMeter - currentSprintMeter;
				if (num < 0f)
				{
					__instance.sprintMeter = Mathf.Max(currentSprintMeter + num * ConfigSync.instance.staminaConsumptionMultiplier, 0f);
				}
				else if (num > 0f)
				{
					__instance.sprintMeter = Mathf.Min(currentSprintMeter + num * ConfigSync.instance.staminaRegenMultiplier, 1f);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPrefix]
		public static void LateUpdatePrefix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				currentSprintMeter = __instance.sprintMeter;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyPostfix]
		public static void LateUpdateStaminaPostfix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				float num = __instance.sprintMeter - currentSprintMeter;
				if (num < 0f)
				{
					__instance.sprintMeter = Mathf.Max(currentSprintMeter + num * ConfigSync.instance.staminaConsumptionMultiplier, 0f);
				}
				else if (num > 0f)
				{
					__instance.sprintMeter = Mathf.Min(currentSprintMeter + num * ConfigSync.instance.staminaRegenMultiplier, 1f);
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPrefix]
		public static void JumpPerformedPrefix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				currentSprintMeter = __instance.sprintMeter;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Jump_performed")]
		[HarmonyPostfix]
		public static void JumpPerformedPostfix(PlayerControllerB __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && __instance.isPlayerControlled)
			{
				float num = __instance.sprintMeter - currentSprintMeter;
				if (num < 0f)
				{
					__instance.sprintMeter = Mathf.Max(new float[1] { currentSprintMeter + num * ConfigSync.instance.jumpStaminaConsumptionMultiplier });
				}
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "Update")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> SpoofWeightValuesUpdate(IEnumerable<CodeInstruction> instructions)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo field = typeof(PlayerControllerB).GetField("carryWeight", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method = typeof(PlayerPatcher).GetMethod("GetAdjustedWeight", BindingFlags.Static | BindingFlags.Public);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && (FieldInfo)list[i].operand == field)
				{
					list[i] = new CodeInstruction(OpCodes.Call, (object)method);
					list.RemoveAt(i - 1);
				}
			}
			return list.AsEnumerable();
		}

		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		[HarmonyTranspiler]
		public static IEnumerable<CodeInstruction> SpoofWeightValuesLateUpdate(IEnumerable<CodeInstruction> instructions)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo field = typeof(PlayerControllerB).GetField("carryWeight", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method = typeof(PlayerPatcher).GetMethod("GetAdjustedWeight", BindingFlags.Static | BindingFlags.Public);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && (FieldInfo)list[i].operand == field)
				{
					list[i] = new CodeInstruction(OpCodes.Call, (object)method);
					list.RemoveAt(i - 1);
				}
			}
			return list.AsEnumerable();
		}

		public static float GetAdjustedWeight()
		{
			return Mathf.Max(((Object)(object)StartOfRound.Instance.localPlayerController != (Object)null) ? (StartOfRound.Instance.localPlayerController.carryWeight * ConfigSync.instance.carryWeightPenaltyMultiplier) : 1f, 1f);
		}
	}
}
namespace BetterStamina.Config
{
	[Serializable]
	public static class ConfigSettings
	{
		public static ConfigEntry<float> staminaRegenMultiplierConfig;

		public static ConfigEntry<float> staminaConsumptionMultiplierConfig;

		public static ConfigEntry<float> jumpStaminaConsumptionMultiplierConfig;

		public static ConfigEntry<float> carryWeightPenaltyMultiplierConfig;

		public static ConfigEntry<float> movementSpeedMultiplierConfig;

		public static void BindConfigSettings()
		{
			Plugin.Log("BindingConfigs");
			staminaRegenMultiplierConfig = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("BetterStamina", "StaminaRegenMultiplier", 1.5f, "Multiplier for how fast your stamina regens.");
			staminaConsumptionMultiplierConfig = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("BetterStamina", "StaminaConsumptionMultiplier", 0.75f, "Multiplier for how much stamina drains while sprinting.");
			jumpStaminaConsumptionMultiplierConfig = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("BetterStamina", "JumpStaminaConsumptionMultiplier", 0.75f, "Multiplier for how much stamina jumping consumes.");
			carryWeightPenaltyMultiplierConfig = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("BetterStamina", "CarryWeightPenaltyMultiplier", 0.5f, "Multiplier for how much your speed/stamina consumption are affected by weight.");
			movementSpeedMultiplierConfig = ((BaseUnityPlugin)Plugin.instance).Config.Bind<float>("BetterStamina", "MovementSpeedMultiplier", 1f, "Player movement speed multiplier.");
		}
	}
	[Serializable]
	[HarmonyPatch]
	public class ConfigSync
	{
		public static ConfigSync defaultConfig;

		public static ConfigSync instance;

		public static PlayerControllerB localPlayerController;

		public static bool isSynced = false;

		private static float defaultMovementSpeed = 4.6f;

		public float staminaRegenMultiplier = 1f;

		public float staminaConsumptionMultiplier = 1f;

		public float jumpStaminaConsumptionMultiplier = 1f;

		public float carryWeightPenaltyMultiplier = 1f;

		public float movementSpeedMultiplier = 1f;

		public static void BuildDefaultConfigSync()
		{
			instance = new ConfigSync();
		}

		public static void BuildServerConfigSync()
		{
			if (defaultConfig == null)
			{
				defaultConfig = new ConfigSync();
				defaultConfig.staminaRegenMultiplier = ConfigSettings.staminaRegenMultiplierConfig.Value;
				defaultConfig.staminaConsumptionMultiplier = ConfigSettings.staminaConsumptionMultiplierConfig.Value;
				defaultConfig.jumpStaminaConsumptionMultiplier = ConfigSettings.jumpStaminaConsumptionMultiplierConfig.Value;
				defaultConfig.carryWeightPenaltyMultiplier = ConfigSettings.carryWeightPenaltyMultiplierConfig.Value;
				defaultConfig.movementSpeedMultiplier = ConfigSettings.movementSpeedMultiplierConfig.Value;
				instance = defaultConfig;
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		[HarmonyPostfix]
		public static void InitializeLocalPlayer(PlayerControllerB __instance)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			localPlayerController = __instance;
			if (NetworkManager.Singleton.IsServer)
			{
				BuildServerConfigSync();
				NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterStamina-OnRequestConfigSync", new HandleNamedMessageDelegate(OnReceiveConfigSyncRequest));
				OnLocalClientConfigSync();
			}
			else
			{
				isSynced = false;
				BuildDefaultConfigSync();
				NetworkManager.Singleton.CustomMessagingManager.RegisterNamedMessageHandler("BetterStamina-OnReceiveConfigSync", new HandleNamedMessageDelegate(OnReceiveConfigSync));
				RequestConfigSync();
			}
		}

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

		public static void OnReceiveConfigSyncRequest(ulong clientId, FastBufferReader reader)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsServer)
			{
				Plugin.Log("Receiving config sync request from client with id: " + clientId + ". Sending config sync to client.");
				byte[] array = SerializeConfigToByteArray(instance);
				FastBufferWriter val = default(FastBufferWriter);
				((FastBufferWriter)(ref val))..ctor(array.Length + 4, (Allocator)2, -1);
				int num = array.Length;
				((FastBufferWriter)(ref val)).WriteValueSafe<int>(ref num, default(ForPrimitives));
				((FastBufferWriter)(ref val)).WriteBytesSafe(array, -1, 0);
				NetworkManager.Singleton.CustomMessagingManager.SendNamedMessage("BetterStamina-OnReceiveConfigSync", clientId, val, (NetworkDelivery)3);
			}
		}

		public static void OnReceiveConfigSync(ulong clientId, FastBufferReader reader)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (((FastBufferReader)(ref reader)).TryBeginRead(4))
			{
				int num = default(int);
				((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref num, default(ForPrimitives));
				if (((FastBufferReader)(ref reader)).TryBeginRead(num))
				{
					Plugin.Log("Receiving config sync from server.");
					byte[] data = new byte[num];
					((FastBufferReader)(ref reader)).ReadBytesSafe(ref data, num, 0);
					instance = DeserializeFromByteArray(data);
					OnLocalClientConfigSync();
				}
				else
				{
					Plugin.LogError("Error receiving sync from server.");
				}
			}
			else
			{
				Plugin.LogError("Error receiving bytes length.");
			}
		}

		public static void OnLocalClientConfigSync()
		{
			localPlayerController.movementSpeed = defaultMovementSpeed * instance.movementSpeedMultiplier;
			isSynced = true;
		}

		public static byte[] SerializeConfigToByteArray(ConfigSync config)
		{
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			MemoryStream memoryStream = new MemoryStream();
			binaryFormatter.Serialize(memoryStream, config);
			return memoryStream.ToArray();
		}

		public static ConfigSync DeserializeFromByteArray(byte[] data)
		{
			MemoryStream serializationStream = new MemoryStream(data);
			BinaryFormatter binaryFormatter = new BinaryFormatter();
			return (ConfigSync)binaryFormatter.Deserialize(serializationStream);
		}
	}
}

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 HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("BuyableShotgunShells")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyCopyright("Copyright © 2023 MegaPiggy")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BuyableShotgunShells")]
[assembly: AssemblyTitle("BuyableShotgunShells")]
[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 BuyableShotgunShells
{
	[BepInPlugin("MegaPiggy.BuyableShotgunShells", "Buyable Shotgun Shells", "1.0.1")]
	public class BuyableShotgunShells : BaseUnityPlugin
	{
		private const string modGUID = "MegaPiggy.BuyableShotgunShells";

		private const string modName = "Buyable Shotgun Shells";

		private const string modVersion = "1.0.1";

		private readonly Harmony harmony = new Harmony("MegaPiggy.BuyableShotgunShells");

		private static BuyableShotgunShells Instance;

		public int ShellPrice;

		public bool added;

		private static ManualLogSource LoggerInstance => ((BaseUnityPlugin)Instance).Logger;

		public List<Item> AllItems => Resources.FindObjectsOfTypeAll<Item>().Concat(Object.FindObjectsByType<Item>((FindObjectsInactive)1, (FindObjectsSortMode)1)).ToList();

		public Item ShotgunShell => ((IEnumerable<Item>)AllItems).FirstOrDefault((Func<Item, bool>)((Item item) => ((Object)item).name == "GunAmmo"));

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			harmony.PatchAll();
			ShellPrice = ((BaseUnityPlugin)this).Config.Bind<int>("Prices", "ShotgunShellPrice", 20, "Credits needed to buy shotgun shells").Value;
			SceneManager.sceneLoaded += OnSceneLoaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin Buyable Shotgun Shells is loaded with version 1.0.1!");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (!added && ((Scene)(ref scene)).name == "MainMenu")
			{
				added = true;
				ShotgunShell.itemName = "Shells";
				Items.RegisterShopItem(ShotgunShell, ShellPrice);
			}
		}
	}
}

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 GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
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: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("FPSSpectate")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("FPS spectate camera")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+ada41809ef3e18d1ac6f547212c170f1debd12d4")]
[assembly: AssemblyProduct("FPSSpectate")]
[assembly: AssemblyTitle("FPSSpectate")]
[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 FPSSpectate
{
	[BepInPlugin("5Bit.FPSSpectate", "FPSSpectate", "1.0.0")]
	public class FPSSpectate : BaseUnityPlugin
	{
		private const string modGUID = "5Bit.FPSSpectate";

		private const string modName = "FPSSpectate";

		private const string modVersion = "1.0.0";

		private readonly Harmony harmony = new Harmony("5Bit.FPSSpectate");

		private static FPSSpectate Instance;

		internal static ManualLogSource mls;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("5Bit.FPSSpectate");
			harmony.PatchAll();
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "FPSSpectate";

		public const string PLUGIN_NAME = "FPSSpectate";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace FPSSpectate.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class FPSSpectatePatch
	{
		private const float SPECTATE_OFFSET = 1.5f;

		private static bool firstPerson = true;

		private static bool debounced = false;

		[HarmonyPatch("LateUpdate")]
		[HarmonyPostfix]
		private static void LateUpdate(PlayerControllerB __instance)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			if (((ButtonControl)Keyboard.current.vKey).wasPressedThisFrame && !debounced)
			{
				firstPerson = !firstPerson;
				debounced = true;
			}
			if (((ButtonControl)Keyboard.current.vKey).wasReleasedThisFrame)
			{
				debounced = false;
			}
			if ((Object)(object)__instance.spectatedPlayerScript != (Object)null && firstPerson)
			{
				Transform transform = ((Component)__instance.spectateCameraPivot).transform;
				Transform transform2 = ((Component)__instance.spectatedPlayerScript.visorCamera).transform;
				Vector3 position = transform2.position;
				Vector3 forward = transform2.forward;
				transform.position = position + ((Vector3)(ref forward)).normalized * 1.5f;
				transform.rotation = transform2.rotation;
			}
		}
	}
}

using System.Diagnostics;
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("HideChat")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("HideChat")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("fa900f4d-71b1-433a-ad23-a10fc53dc3d8")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace HideChat
{
	[BepInPlugin("Miodec.HideChat", "Hide Chat", "1.0.0")]
	public class HidePlayerNames : BaseUnityPlugin
	{
		private const string modGUID = "Miodec.HideChat";

		private const string modName = "Hide Chat";

		private const string modVersion = "1.0.0";

		private static HidePlayerNames Instance;

		internal ManualLogSource mls;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Miodec.HideChat");
			mls.LogDebug((object)"hidechat is awake");
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
		}
	}
}
namespace HideChat.Patches
{
	[HarmonyPatch(typeof(HUDManager))]
	internal class HUDManagerPatch
	{
		[HarmonyPatch("OpenMenu_performed")]
		[HarmonyPatch("SubmitChat_performed")]
		[HarmonyPatch("AddChatMessage")]
		[HarmonyPostfix]
		public static void FadeToNothing(ref HUDManager __instance)
		{
			__instance.PingHUDElement(__instance.Chat, 5f, 1f, 0f);
		}
	}
}

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 HarmonyLib;
using Microsoft.CodeAnalysis;

[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("HideModList")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Hides the LC api modlist info")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("HideModList")]
[assembly: AssemblyTitle("HideModList")]
[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 HideModList
{
	[HarmonyPatch(typeof(HUDManager), "DisplayTip")]
	public static class DisplayTipPatch
	{
		public static bool Prefix(HUDManager __instance, string headerText, string bodyText, bool isWarning = false, bool useSave = false, string prefsKey = "LC_Tip1")
		{
			if (headerText.StartsWith("Mod List"))
			{
				return false;
			}
			return true;
		}
	}
	[BepInPlugin("HideModList", "HideModList", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			Harmony val = new Harmony("plugin.HideModList");
			val.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin HideModList is loaded!");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "HideModList";

		public const string PLUGIN_NAME = "HideModList";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}

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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IntroTweaks.Core;
using IntroTweaks.Utils;
using Microsoft.CodeAnalysis;
using TMPro;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.6", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("IntroTweaks")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Seamless skipping of Lethal Company intro/menu screens.")]
[assembly: AssemblyFileVersion("1.4.1.0")]
[assembly: AssemblyInformationalVersion("1.4.1+b403cdf67ce1f6c35ef90e76df10874ec29de4f5")]
[assembly: AssemblyProduct("IntroTweaks")]
[assembly: AssemblyTitle("IntroTweaks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.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]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 IntroTweaks
{
	[BepInPlugin("io.github.IntroTweaks", "IntroTweaks", "1.4.1")]
	public class Plugin : BaseUnityPlugin
	{
		internal static string SelectedMode;

		private Harmony patcher;

		private static bool menuLoaded;

		internal static ManualLogSource Logger { get; private set; }

		public static PluginConfig Config { get; private set; }

		public static bool ModInstalled(string name)
		{
			return Chainloader.PluginInfos.Values.Any((PluginInfo p) => p.Metadata.GUID.ToLower().Contains(name) || p.Metadata.Name.ToLower() == name.ToLower());
		}

		private void Awake()
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			Config = new PluginConfig(((BaseUnityPlugin)this).Config);
			if (!PluginEnabled(logDisabled: true))
			{
				return;
			}
			SceneManager.sceneLoaded += SceneLoaded;
			if (Config.SKIP_SPLASH_SCREENS)
			{
				Task.Run((Action)SkipSplashScreen);
			}
			Config.InitBindings();
			SelectedMode = Config.AUTO_SELECT_MODE.ToLower();
			try
			{
				patcher = new Harmony("io.github.IntroTweaks");
				patcher.PatchAll();
				Logger.LogInfo((object)"Plugin loaded.");
			}
			catch (Exception ex)
			{
				Logger.LogError((object)ex);
			}
		}

		public bool PluginEnabled(bool logDisabled = false)
		{
			bool pLUGIN_ENABLED = Config.PLUGIN_ENABLED;
			if (!pLUGIN_ENABLED && logDisabled)
			{
				Logger.LogInfo((object)"IntroTweaks disabled globally.");
			}
			return pLUGIN_ENABLED;
		}

		private void SkipSplashScreen()
		{
			Logger.LogDebug((object)"Skipping splash screens. Ew.");
			while (!menuLoaded)
			{
				SplashScreen.Stop((StopBehavior)0);
			}
		}

		private void SceneLoaded(Scene scene, LoadSceneMode _)
		{
			switch (((Scene)(ref scene)).name)
			{
			case "InitScene":
			case "InitSceneLaunchOptions":
			case "MainMenu":
				menuLoaded = true;
				break;
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "IntroTweaks";

		public const string PLUGIN_NAME = "IntroTweaks";

		public const string PLUGIN_VERSION = "1.4.1";
	}
}
namespace IntroTweaks.Utils
{
	internal class DisplayUtil
	{
		public static List<DisplayInfo> Displays { get; private set; } = new List<DisplayInfo>();


		internal static void Move(int displayIndex)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			Screen.GetDisplayLayout(Displays);
			int num = Displays.IndexOf(Screen.mainWindowDisplayInfo);
			if (displayIndex != num)
			{
				MoveWindowAsync(displayIndex);
			}
		}

		private static async void MoveWindowAsync(int index)
		{
			await MoveWindowTask(index);
		}

		private static async Task MoveWindowTask(int index)
		{
			if (index >= Displays.Count)
			{
				await Task.CompletedTask;
				Plugin.Logger.LogDebug((object)"Display index out of bounds for current layout!");
				return;
			}
			DisplayInfo val = Displays[index];
			Vector2Int zero = Vector2Int.zero;
			if ((int)Screen.fullScreenMode != 3)
			{
				((Vector2Int)(ref zero)).x = ((Vector2Int)(ref zero)).x + val.width / 2;
				((Vector2Int)(ref zero)).y = ((Vector2Int)(ref zero)).y + val.height / 2;
			}
			AsyncOperation operation = Screen.MoveMainWindowTo(ref val, zero);
			while (operation.progress < 1f)
			{
				await Task.Yield();
			}
			Plugin.Logger.LogDebug((object)("Game moved to display: " + Displays[index].name));
		}
	}
	internal class RectUtil
	{
		internal static void ResetAnchoredPos(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			rect.anchoredPosition = Vector2.zero;
			rect.anchoredPosition3D = Vector3.zero;
		}

		internal static void ResetPivot(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rect.pivot = Vector2.zero;
		}

		internal static void ResetSizeDelta(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			rect.sizeDelta = Vector2.zero;
		}

		internal static void EditOffsets(RectTransform rect, Vector2 max, Vector2 min)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			rect.offsetMax = max;
			rect.offsetMin = min;
		}

		internal static void EditAnchors(RectTransform rect, Vector2 max, Vector2 min)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMax = max;
			rect.anchorMin = min;
		}

		internal static void AnchorToBottom(RectTransform rect)
		{
			//IL_0017: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			ResetSizeDelta(rect);
			ResetAnchoredPos(rect);
			EditAnchors(rect, new Vector2(0.5f, 0f), new Vector2(0.5f, 0f));
			EditOffsets(rect, new Vector2(0f, 0f), new Vector2(0f, 0f));
			((Transform)rect).localRotation = Quaternion.identity;
			((Transform)rect).localPosition = new Vector3(0f, -205f, 0f);
		}
	}
}
namespace IntroTweaks.Patches
{
	[HarmonyPatch(typeof(InitializeGame))]
	internal class InitializeGamePatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Start")]
		private static void DisableBootAnimation(ref bool __runOriginal)
		{
			int gAME_STARTUP_DISPLAY = Plugin.Config.GAME_STARTUP_DISPLAY;
			if (gAME_STARTUP_DISPLAY >= 0)
			{
				DisplayUtil.Move(gAME_STARTUP_DISPLAY);
			}
			if (Plugin.Config.SKIP_BOOT_ANIMATION)
			{
				SceneManager.LoadScene("MainMenu");
				__runOriginal = false;
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatch
	{
		public static Color32 DARK_ORANGE = new Color32((byte)175, (byte)115, (byte)0, byte.MaxValue);

		private static GameObject activateCosmetics;

		internal static Transform MenuContainer = null;

		internal static Transform MenuPanel = null;

		internal static GameObject VersionNum = null;

		private static MenuManager Instance;

		public static int gameVer { get; private set; }

		public static TextMeshProUGUI versionText { get; private set; }

		internal static void TryReplaceVersionText()
		{
			if (Plugin.Config.CUSTOM_VERSION_TEXT && Object.op_Implicit((Object)(object)VersionNum) && Object.op_Implicit((Object)(object)MenuPanel))
			{
				GameObject obj = Object.Instantiate<GameObject>(VersionNum, MenuPanel);
				((Object)obj).name = "VersionNumberText";
				versionText = InitTextMesh(obj.GetComponent<TextMeshProUGUI>());
				RectUtil.AnchorToBottom(((Component)versionText).gameObject.GetComponent<RectTransform>());
				VersionNum.SetActive(false);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Init(MenuManager __instance)
		{
			Instance = __instance;
			((MonoBehaviour)Instance).StartCoroutine(PatchMenuDelayed());
		}

		private static IEnumerator PatchMenuDelayed()
		{
			yield return (object)new WaitForSeconds(0f);
			GameObject obj = GameObject.Find("MenuContainer");
			MenuContainer = ((obj != null) ? obj.transform : null);
			Transform menuContainer = MenuContainer;
			MenuPanel = ((menuContainer != null) ? menuContainer.Find("MainButtons") : null);
			Transform menuContainer2 = MenuContainer;
			object versionNum;
			if (menuContainer2 == null)
			{
				versionNum = null;
			}
			else
			{
				Transform obj2 = menuContainer2.Find("VersionNum");
				versionNum = ((obj2 != null) ? ((Component)obj2).gameObject : null);
			}
			VersionNum = (GameObject)versionNum;
			PatchMenu();
		}

		private static void PatchMenu()
		{
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (Plugin.Config.FIX_MENU_PANELS)
				{
					FixPanelAlignment(MenuPanel);
					FixPanelAlignment(MenuContainer.Find("LobbyHostSettings"));
					FixPanelAlignment(MenuContainer.Find("LobbyList"));
					FixPanelAlignment(MenuContainer.Find("LoadingScreen"));
					Plugin.Logger.LogDebug((object)"Fixed menu panel alignment.");
				}
				IEnumerable<GameObject> buttons = from b in ((Component)MenuPanel).GetComponentsInChildren<Button>(true)
					select ((Component)b).gameObject;
				if (Plugin.Config.ALIGN_MENU_BUTTONS)
				{
					AlignButtons(buttons);
				}
				if (Plugin.Config.REMOVE_CREDITS_BUTTON)
				{
					RemoveCreditsButton(buttons);
				}
				bool changeRenderMode = Plugin.Config.FIX_MENU_CANVAS;
				if (Plugin.ModInstalled("MoreCompany"))
				{
					Plugin.Logger.LogDebug((object)"MoreCompany found! Edits have been made to UI elements.");
					changeRenderMode = false;
					GameObject obj = GameObject.Find("GlobalScale");
					obj.GetComponentInParent<Canvas>().pixelPerfect = true;
					GameObject gameObject = ((Component)obj.transform.Find("CosmeticsScreen")).gameObject;
					Transform transform = ((Component)gameObject.transform.Find("SpinAreaButton")).transform;
					transform.localScale = new Vector3(0.48f, 0.55f, 0.46f);
					transform.position = new Vector3(421.65f, 245.7f, 200f);
					Transform transform2 = ((Component)gameObject.transform.Find("ExitButton")).transform;
					Transform transform3 = FindInParent(gameObject, "ActivateButton").transform;
					activateCosmetics = ((Component)transform3).gameObject;
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(424.06f, 241.65f, 166.2f);
					Vector3 position = (transform3.position = val);
					transform2.position = position;
					transform2.SetAsLastSibling();
					((Component)gameObject.transform.Find("CosmeticsHolderBorder")).transform.localScale = new Vector3(2.4f, 2.1f, 1f);
					Transform transform4 = ((Component)Instance.menuButtons.transform.Find("HeaderImage")).transform;
					transform4.localScale = new Vector3(5f, 5f, 5f);
					Vector3 position2 = default(Vector3);
					((Vector3)(ref position2))..ctor(1093.05f, 647.79f, -35.33f);
					transform4.position = position2;
				}
				TweakCanvasSettings(Instance.menuButtons, changeRenderMode);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error occurred in Start patch. SAJ.\n{arg}");
			}
			if (Plugin.Config.REMOVE_NEWS_PANEL)
			{
				Instance.NewsPanel.SetActive(false);
			}
			if (Plugin.Config.REMOVE_LAN_WARNING)
			{
				Instance.lanWarningContainer.SetActive(false);
			}
			if (Plugin.Config.REMOVE_LAUNCHED_IN_LAN)
			{
				TextMeshProUGUI launchedInLanModeText = Instance.launchedInLanModeText;
				GameObject val3 = ((launchedInLanModeText != null) ? ((Component)launchedInLanModeText).gameObject : null);
				if (Object.op_Implicit((Object)(object)val3))
				{
					val3.SetActive(false);
				}
			}
			if (Plugin.Config.AUTO_SELECT_HOST)
			{
				Instance.ClickHostButton();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void UpdatePatch(MenuManager __instance)
		{
			bool activeSelf = __instance.menuButtons.activeSelf;
			if ((Object)(object)versionText == (Object)null)
			{
				TryReplaceVersionText();
				return;
			}
			((TMP_Text)versionText).text = ((TMP_Text)versionText).text.Replace("$VERSION", gameVer.ToString());
			GameObject gameObject = ((Component)versionText).gameObject;
			if (!gameObject.activeSelf && activeSelf)
			{
				gameObject.SetActive(true);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("ClickHostButton")]
		private static void DisableMenuOnHost(MenuManager __instance)
		{
			__instance.menuButtons.SetActive(false);
			if (Plugin.Config.CUSTOM_VERSION_TEXT)
			{
				((Component)versionText).gameObject.SetActive(false);
			}
		}

		private static TextMeshProUGUI InitTextMesh(TextMeshProUGUI tmp)
		{
			int gameVersionNum = GameNetworkManager.Instance.gameVersionNum;
			gameVer = Mathf.Abs(Plugin.Config.VERSION_TEXT_FORMAT.ToLower().Equals("short") ? (gameVersionNum - 16440) : gameVersionNum);
			((TMP_Text)tmp).text = Plugin.Config.VERSION_TEXT;
			((TMP_Text)tmp).fontSize = Mathf.Clamp(Plugin.Config.VERSION_TEXT_SIZE, 10f, 40f);
			((TMP_Text)tmp).alignment = (TextAlignmentOptions)514;
			TweakTextSettings(tmp);
			return tmp;
		}

		private static void TweakTextSettings(TextMeshProUGUI tmp, bool overflow = true, bool wordWrap = false)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (overflow)
			{
				((TMP_Text)tmp).overflowMode = (TextOverflowModes)0;
			}
			((TMP_Text)tmp).enableWordWrapping = wordWrap;
			((TMP_Text)tmp).faceColor = DARK_ORANGE;
		}

		private static void TweakCanvasSettings(GameObject panel, bool changeRenderMode)
		{
			Canvas componentInParent = panel.GetComponentInParent<Canvas>();
			componentInParent.pixelPerfect = true;
			if (changeRenderMode)
			{
				componentInParent.renderMode = (RenderMode)0;
			}
		}

		private static void FixPanelAlignment(Transform panel)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = ((Component)panel).gameObject.GetComponent<RectTransform>();
			RectUtil.ResetSizeDelta(component);
			RectUtil.ResetAnchoredPos(component);
			RectUtil.EditOffsets(component, new Vector2(-20f, -25f), new Vector2(20f, 25f));
			FixScale(((Component)panel).gameObject);
		}

		internal static void FixScale(GameObject obj)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			obj.transform.localScale = new Vector3(1.02f, 1.06f, 1.02f);
		}

		private static void RemoveCreditsButton(IEnumerable<GameObject> buttons)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = buttons.First((GameObject b) => ((Object)b).name == "QuitButton");
			GameObject val = buttons.First((GameObject b) => ((Object)b).name == "Credits");
			val.SetActive(false);
			obj.transform.localPosition = val.transform.localPosition;
			foreach (GameObject button in buttons)
			{
				if (Object.op_Implicit((Object)(object)button) && !((Object)(object)button == (Object)(object)val))
				{
					Vector3 localPosition = button.transform.localPosition;
					button.transform.localPosition = new Vector3(localPosition.x, localPosition.y - 45f, localPosition.z);
				}
			}
			Plugin.Logger.LogDebug((object)"Removed credits button.");
		}

		private static void AlignButtons(IEnumerable<GameObject> buttons)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			Vector3 localPosition = ((Transform)buttons.First((GameObject b) => ((Object)b).name == "HostButton").GetComponent<RectTransform>()).localPosition;
			foreach (GameObject button in buttons)
			{
				if (Object.op_Implicit((Object)(object)button))
				{
					RectTransform component = button.GetComponent<RectTransform>();
					int num = (Plugin.Config.REMOVE_CREDITS_BUTTON ? 20 : (-5));
					((Transform)component).localPosition = new Vector3(localPosition.x + 20f, ((Transform)component).localPosition.y + (float)num, localPosition.z);
					TextMeshProUGUI componentInChildren = button.GetComponentInChildren<TextMeshProUGUI>();
					FixScale(((Component)componentInChildren).gameObject);
					TweakTextSettings(componentInChildren);
					((TMP_Text)componentInChildren).fontSize = 15f;
					((TMP_Text)componentInChildren).wordSpacing = ((TMP_Text)componentInChildren).wordSpacing - 25f;
					RectTransform component2 = ((Component)componentInChildren).gameObject.GetComponent<RectTransform>();
					RectUtil.ResetAnchoredPos(component2);
					RectUtil.ResetSizeDelta(component2);
					RectUtil.EditOffsets(component2, Vector2.zero, new Vector2(5f, 0f));
				}
			}
			Plugin.Logger.LogDebug((object)"Aligned menu buttons.");
		}

		private static GameObject GetButton(Transform panel, string name)
		{
			try
			{
				return ((Component)panel.Find(name)).gameObject;
			}
			catch (Exception arg)
			{
				if (name != "ModSettingsButton")
				{
					Plugin.Logger.LogError((object)$"Error getting button: {name}\n{arg}");
				}
				return null;
			}
		}

		private static GameObject FindInParent(GameObject obj, string name)
		{
			Transform parent = obj.transform.parent;
			try
			{
				return ((Component)parent.Find(name)).gameObject;
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error finding '{name}' in: {((Object)parent).name}\n{arg}");
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(PreInitSceneScript))]
	internal class PreSceneInitPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void FinishedFirstLaunch()
		{
			IngamePlayerSettings instance = IngamePlayerSettings.Instance;
			if (instance != null)
			{
				instance.SetPlayerFinishedLaunchOptions();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SkipToFinalSetting")]
		internal static void SkipToSelectedMode(PreInitSceneScript __instance, ref bool ___choseLaunchOption)
		{
			if (!(Plugin.SelectedMode != "online") || !(Plugin.SelectedMode != "lan"))
			{
				CollectionExtensions.Do<GameObject>((IEnumerable<GameObject>)__instance.LaunchSettingsPanels, (Action<GameObject>)delegate(GameObject panel)
				{
					panel.SetActive(false);
				});
				__instance.currentLaunchSettingPanel = 0;
				((TMP_Text)__instance.headerText).text = "";
				((Component)__instance.blackTransition).gameObject.SetActive(false);
				__instance.continueButton.gameObject.SetActive(false);
				___choseLaunchOption = true;
				__instance.mainAudio.PlayOneShot(__instance.selectSFX);
				SceneManager.LoadScene((Plugin.SelectedMode == "online") ? "InitScene" : "InitSceneLANMode");
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("PlayFirstDayShipAnimation")]
		private static bool DisableSpeaker()
		{
			return !Plugin.Config.DISABLE_FIRST_DAY_SFX;
		}
	}
}
namespace IntroTweaks.Core
{
	public struct Category
	{
		public static Category GENERAL => new Category("0 >> General << 0");

		public static Category INTRO_TWEAKS => new Category("1 >> Intro << 1");

		public static Category MENU_TWEAKS => new Category("2 >> Main Menu << 2");

		public static Category VERSION_TEXT => new Category("3 >> Custom Version Text << 3");

		public static Category MISC => new Category("4 >> Miscellaneous << 4");

		public string Value { get; private set; }

		private Category(string value)
		{
			Value = value;
		}
	}
	public class PluginConfig
	{
		private readonly ConfigFile configFile;

		public bool PLUGIN_ENABLED { get; private set; }

		public bool SKIP_SPLASH_SCREENS { get; private set; }

		public bool SKIP_BOOT_ANIMATION { get; private set; }

		public string AUTO_SELECT_MODE { get; private set; }

		public bool AUTO_SELECT_HOST { get; private set; }

		public bool ALIGN_MENU_BUTTONS { get; private set; }

		public bool FIX_MENU_CANVAS { get; private set; }

		public bool FIX_MENU_PANELS { get; private set; }

		public bool REMOVE_LAN_WARNING { get; private set; }

		public bool REMOVE_LAUNCHED_IN_LAN { get; private set; }

		public bool REMOVE_NEWS_PANEL { get; private set; }

		public bool REMOVE_CREDITS_BUTTON { get; private set; }

		public bool CUSTOM_VERSION_TEXT { get; private set; }

		public string VERSION_TEXT { get; private set; }

		public string VERSION_TEXT_FORMAT { get; private set; }

		public float VERSION_TEXT_SIZE { get; private set; }

		public bool DISABLE_FIRST_DAY_SFX { get; private set; }

		public int GAME_STARTUP_DISPLAY { get; private set; }

		public PluginConfig(ConfigFile cfg)
		{
			configFile = cfg;
			PLUGIN_ENABLED = NewEntry("bEnabled", defaultVal: true, "Enable or disable the plugin globally.");
			SKIP_SPLASH_SCREENS = NewEntry(Category.INTRO_TWEAKS, "bSkipSplashScreens", defaultVal: true, "Skips those pesky Unity and Zeekers startup logos!");
		}

		private T NewEntry<T>(string key, T defaultVal, string desc)
		{
			return NewEntry(Category.GENERAL, key, defaultVal, desc);
		}

		private T NewEntry<T>(Category category, string key, T defaultVal, string desc)
		{
			return configFile.Bind<T>(category.Value, key, defaultVal, desc).Value;
		}

		public void InitBindings()
		{
			SKIP_BOOT_ANIMATION = NewEntry(Category.INTRO_TWEAKS, "bSkipBootAnimation", defaultVal: true, "If the loading animation (booting OS) should be skipped.");
			AUTO_SELECT_MODE = NewEntry(Category.INTRO_TWEAKS, "sAutoSelectMode", "ONLINE", "Which mode to automatically enter into after the splash screen.\nValid options: ONLINE, LAN, OFF");
			AUTO_SELECT_HOST = NewEntry(Category.INTRO_TWEAKS, "bAutoSelectHost", defaultVal: false, "Whether the 'Host' button is automatically selected when the Online/LAN menu loads.");
			ALIGN_MENU_BUTTONS = NewEntry(Category.MENU_TWEAKS, "bAlignMenuButtons", defaultVal: true, "If the main menu buttons should align with each other.");
			FIX_MENU_CANVAS = NewEntry(Category.MENU_TWEAKS, "bFixMenuCanvas", defaultVal: true, "Whether the main menu canvas should have its settings corrected.\nMay cause overlapping issues, only turn it on if you aren't using other menu mods.");
			FIX_MENU_PANELS = NewEntry(Category.MENU_TWEAKS, "bFixMenuPanels", defaultVal: true, "The main menu panels (host, servers, loading screen) all have anchoring, offset and sizing issues.\nThis option helps solve them and improve the look of the menu.\n\nMAY BREAK SOME MODS.");
			REMOVE_LAN_WARNING = NewEntry(Category.MENU_TWEAKS, "bRemoveLanWarning", defaultVal: true, "Hides the warning popup when hosting a LAN session.");
			REMOVE_LAUNCHED_IN_LAN = NewEntry(Category.MENU_TWEAKS, "bRemoveLaunchedInLanText", defaultVal: true, "Hides the 'Launched in LAN mode' text below the Quit button.");
			REMOVE_NEWS_PANEL = NewEntry(Category.MENU_TWEAKS, "bRemoveNewsPanel", defaultVal: false, "Hides the panel that displays news such as game updates.");
			REMOVE_CREDITS_BUTTON = NewEntry(Category.MENU_TWEAKS, "bRemoveCreditsButton", defaultVal: true, "Hides the 'Credits' button on the main menu. The other buttons are automatically adjusted.");
			CUSTOM_VERSION_TEXT = NewEntry(Category.VERSION_TEXT, "bCustomVersionText", defaultVal: true, "Whether to replace the game's version text with a custom alternative.");
			VERSION_TEXT = NewEntry(Category.VERSION_TEXT, "sVersionText", "v$VERSION\n[MODDED]", "Replace the game's version text with this custom text in the main menu.\nTo insert the version number, use the $VERSION syntax. E.g. Ver69 would be Ver$VERSION");
			VERSION_TEXT_FORMAT = NewEntry(Category.VERSION_TEXT, "sVersionTextFormat", "FULL", "Determines how to display game version number.\nValid options: FULL, SHORT");
			VERSION_TEXT_SIZE = NewEntry(Category.VERSION_TEXT, "fVersionTextSize", 20f, "The font size of the version text. Min = 10, Max = 40.");
			DISABLE_FIRST_DAY_SFX = NewEntry(Category.MISC, "bDisableFirstDaySFX", defaultVal: false, "Toggles the first day ship speaker SFX.");
			GAME_STARTUP_DISPLAY = NewEntry(Category.MISC, "iGameStartupDisplay", 0, "The index of the monitor to display the game on when starting.\nYou can find these indexes in your Windows display settings.\nDefaults to 0 (main monitor).");
		}
	}
	internal static class Metadata
	{
		public const string GUID = "io.github.IntroTweaks";

		public const string NAME = "IntroTweaks";

		public const string VERSION = "1.4.1";
	}
}