using System;
using System.Collections;
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.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LevelScaling.LevelStats;
using LevelScaling.Menu;
using LevelScaling.Patches;
using MenuLib;
using MenuLib.MonoBehaviors;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LevelScaling")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LevelScaling")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("94187d6e-952a-4336-b083-0210fe153e6f")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace LevelScaling
{
	public class ChallengeManager
	{
		public enum ChallengeType
		{
			None,
			LightsOut,
			HighQuota,
			LargeMap,
			EnemyRush,
			FragileValuables,
			IncreasedDamage,
			HiddenInformation,
			FoggyLevel,
			TimeAttack,
			OverOvercharge,
			NoMap,
			DangerZone,
			SharedDurability
		}

		public class Challenge
		{
			public ChallengeType type;

			public string name;

			public string info;

			public int Weight => type switch
			{
				ChallengeType.LightsOut => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_LightsOut), 
				ChallengeType.HighQuota => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_HighQuota), 
				ChallengeType.LargeMap => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_LargeMap), 
				ChallengeType.FoggyLevel => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_FoggyLevel), 
				ChallengeType.IncreasedDamage => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_IncreasedDamage), 
				ChallengeType.FragileValuables => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_FragileValuables), 
				ChallengeType.OverOvercharge => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_OverOvercharge), 
				ChallengeType.NoMap => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_NoMap), 
				ChallengeType.EnemyRush => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_EnemyRush), 
				ChallengeType.HiddenInformation => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_HiddenInformation), 
				ChallengeType.DangerZone => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_DangerZone), 
				ChallengeType.SharedDurability => Helpers.GetConfig<int>(Plugin.ChallengeChanceMultiplier_SharedDurability), 
				_ => 0, 
			};

			public int StartingLevel => type switch
			{
				ChallengeType.LightsOut => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_LightsOut), 
				ChallengeType.HighQuota => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_HighQuota), 
				ChallengeType.LargeMap => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_LargeMap), 
				ChallengeType.FoggyLevel => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_FoggyLevel), 
				ChallengeType.IncreasedDamage => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_IncreasedDamage), 
				ChallengeType.FragileValuables => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_FragileValuables), 
				ChallengeType.OverOvercharge => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_OverOvercharge), 
				ChallengeType.NoMap => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_NoMap), 
				ChallengeType.EnemyRush => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_EnemyRush), 
				ChallengeType.HiddenInformation => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_HiddenInformation), 
				ChallengeType.DangerZone => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_DangerZone), 
				ChallengeType.SharedDurability => Helpers.GetConfig<int>(Plugin.ChallengeStartingLevel_SharedDurability), 
				_ => 0, 
			};

			public Challenge(ChallengeType type, string name, string info)
			{
				this.type = type;
				this.name = name;
				this.info = info;
			}
		}

		public static List<ChallengeType> currentChallenges = new List<ChallengeType>();

		public static List<ChallengeType> _blacklistedChallenges = new List<ChallengeType>();

		public static ChallengeType forceChallenge = ChallengeType.None;

		public static Dictionary<string, int> challengesDofD = new Dictionary<string, int>
		{
			{ "currentSeed", 1 },
			{ "lastChallengeLevel", -1 },
			{ "lastChallengeType", -1 }
		};

		public static readonly List<Challenge> allChallenges = new List<Challenge>
		{
			new Challenge(ChallengeType.LightsOut, "Lights Out", "The level's lights have stopped working,<br>you'll be stuck in the dark."),
			new Challenge(ChallengeType.HighQuota, "Overtime", "Taxman is requiring extra effort for this level.<br>Your quotas will be significantly higher."),
			new Challenge(ChallengeType.LargeMap, "Enlarged Level", "This level's layout is much larger than normal.<br>Remember to use your map."),
			new Challenge(ChallengeType.FoggyLevel, "Dense Fog", "There's lots of heavy fog on this level.<br>Visibility will be low, tread carefully."),
			new Challenge(ChallengeType.IncreasedDamage, "Increased Damage", "All incoming damage for both Semibots and enemies<br>will be greatly increased. Be careful."),
			new Challenge(ChallengeType.FragileValuables, "Fragile Valuables", "All valuables are very fragile, regardless of how they<br>look on the outside. Each valuable will be priced higher."),
			new Challenge(ChallengeType.OverOvercharge, "Over-Overcharge", "Overcharge will build up from holding valuables too.<br>Pay close attention and don't explode yourself."),
			new Challenge(ChallengeType.NoMap, "Broken Map", "Your map is disabled, however Semibots will naturally<br>regenerate health slowly; up to the health they started the level with."),
			new Challenge(ChallengeType.EnemyRush, "Enemy Rush", "There are many more enemies than usual on this level,<br>but enemies are lighter, and have significantly reduced health."),
			new Challenge(ChallengeType.HiddenInformation, "Hidden Information", "This level's size and length are randomized, and some important<br>information will be obstructed for the duration of the level."),
			new Challenge(ChallengeType.DangerZone, "Danger Zone", "Semibots will take damage over time, gradually speeding up the longer<br>you spend on the level. Damaging enemies heals all Semibots."),
			new Challenge(ChallengeType.SharedDurability, "Shared Durability", "A portion of damage valuables take is instead given to Semibots. More value<br>lost, more damage given. Extractions will heal Semibots based on value extracted.")
		};

		public static int CurrentSeed
		{
			get
			{
				if (!challengesDofD.ContainsKey("currentSeed"))
				{
					challengesDofD.Add("currentSeed", 1);
				}
				return challengesDofD["currentSeed"];
			}
			set
			{
				if (!challengesDofD.ContainsKey("currentSeed"))
				{
					challengesDofD.Add("currentSeed", value);
				}
				else
				{
					challengesDofD["currentSeed"] = value;
				}
			}
		}

		public static int LastChallengeLevel
		{
			get
			{
				if (!challengesDofD.ContainsKey("lastChallengeLevel"))
				{
					challengesDofD.Add("lastChallengeLevel", -1);
				}
				return challengesDofD["lastChallengeLevel"];
			}
			set
			{
				if (!challengesDofD.ContainsKey("lastChallengeLevel"))
				{
					challengesDofD.Add("lastChallengeLevel", value);
				}
				else
				{
					challengesDofD["lastChallengeLevel"] = value;
				}
			}
		}

		public static int LastChallengeType
		{
			get
			{
				if (!challengesDofD.ContainsKey("lastChallengeType"))
				{
					challengesDofD.Add("lastChallengeType", -1);
				}
				return challengesDofD["lastChallengeType"];
			}
			set
			{
				if (!challengesDofD.ContainsKey("lastChallengeType"))
				{
					challengesDofD.Add("lastChallengeType", value);
				}
				else
				{
					challengesDofD["lastChallengeType"] = value;
				}
			}
		}

		public static bool IsChallengeActive(ChallengeType challenge)
		{
			if (currentChallenges.Contains(challenge))
			{
				return Plugin.LSCompatibilityMode.Value == Plugin.CompatibilityMode.None;
			}
			return false;
		}

		public static Challenge GetChallenge(ChallengeType challenge)
		{
			foreach (Challenge allChallenge in allChallenges)
			{
				if (allChallenge.type == challenge)
				{
					return allChallenge;
				}
			}
			return new Challenge(ChallengeType.None, "????????", "Unknown challenge - can't get any info. Sorry!");
		}

		public static void DetermineChallengeForLevel(int level, int initialSeed)
		{
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04da: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.IsMasterClientOrSingleplayer() || Plugin.LSCompatibilityMode.Value <= Plugin.CompatibilityMode.Host || Helpers.GetConfig<float>(Plugin.ChallengeChanceMultiplier) <= 0f)
			{
				return;
			}
			int num = initialSeed + level;
			Random random = new Random(num);
			int num2 = Mathf.Max(0, level - Mathf.Max(1, LastChallengeLevel) - 1);
			float num3 = SwaggiFunc.DetermineChallengeChance(level);
			float num4 = Mathf.Clamp((float)num2 * 4f, 0f, 20f);
			float num5 = num3 + num4;
			if (num2 >= 3 && level >= 10)
			{
				num5 += 5f;
				if (num2 >= 5)
				{
					num5 += 7f;
				}
			}
			if (level >= 5 && LastChallengeLevel == -1)
			{
				num5 += 15f;
				if (level >= 7)
				{
					num5 += 20f;
				}
			}
			num5 *= Helpers.GetConfig<float>(Plugin.ChallengeChanceMultiplier);
			float num6 = (float)random.Next(0, 1000) / 10f;
			bool flag = (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelShop || (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelTutorial || (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelArena || (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobby || (Object)(object)RunManager.instance.levelCurrent == (Object)(object)RunManager.instance.levelLobbyMenu;
			bool flag2 = level <= 3 || (level <= 20 && level % 5 == 0 && Helpers.GetConfig<bool>(Plugin.ChallengeDisableMoonPhase));
			bool flag3 = num6 >= num5;
			bool flag4 = LastChallengeLevel == level - 1 && random.Next(0, 100) >= 5;
			bool flag5 = MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.QuotaDifficulty) || Helpers.GetConfig<bool>(Plugin.ChallengeGuarantee);
			if (Plugin.DeepLog)
			{
				Helpers.DeepLog($"[ChallengeManager] seed: {num}\n" + $"base chance       = {num3:0.0}%\n" + $"consecutive bonus = {num4:0.0}%\n" + $"final chance      = {num5:0.0}%\n" + "---\n" + $"passes chance     = {!flag3} ({num6:0.0} < {num5:0.0}%) ({Helpers.GetConfig<float>(Plugin.ChallengeChanceMultiplier):0.00}x)\n" + $"passes level type = {!flag} ({RunManager.instance.levelCurrent.NarrativeName})\n" + $"passes level num  = {!flag2} ({level})\n" + $"passes last level = {!flag4} ({LastChallengeLevel} == {level - 1})\n");
			}
			if (flag || (!flag5 && forceChallenge == ChallengeType.None && (flag2 || flag3 || flag4)))
			{
				if (GameManager.Multiplayer())
				{
					LevelStatsSyncing instance = LevelStatsSyncing.instance;
					if (instance != null)
					{
						PhotonView photonView = instance.photonView;
						if (photonView != null)
						{
							photonView.RPC("SyncChallengeRPC", (RpcTarget)0, new object[1] { 0 });
						}
					}
				}
				else
				{
					LevelStatsSyncing.instance?.SyncChallengeRPC(0);
				}
				return;
			}
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			List<Challenge> list = new List<Challenge>();
			foreach (Challenge allChallenge in allChallenges)
			{
				if ((flag5 || ((Helpers.GetConfig<bool>(Plugin.ChallengeDisableLevelRequirements) || LevelGeneratorPatch.CurrentLevel >= allChallenge.StartingLevel) && allChallenge.type != (ChallengeType)LastChallengeType)) && (allChallenge.type != ChallengeType.OverOvercharge || SemiFunc.MoonLevel() >= 2) && ((allChallenge.type != ChallengeType.SharedDurability && allChallenge.type != ChallengeType.FragileValuables) || !MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.Soulstealers)) && !_blacklistedChallenges.Contains(allChallenge.type))
				{
					list.Add(allChallenge);
					num9 += allChallenge.Weight;
				}
			}
			int num10 = random.Next(0, num9);
			foreach (Challenge item in list)
			{
				num8 += item.Weight;
				if (num8 > num10)
				{
					num7 = (int)item.type;
					break;
				}
			}
			if (forceChallenge != 0)
			{
				num7 = (int)forceChallenge;
			}
			forceChallenge = ChallengeType.None;
			LastChallengeLevel = level;
			LastChallengeType = num7;
			if (GameManager.Multiplayer())
			{
				LevelStatsSyncing instance2 = LevelStatsSyncing.instance;
				if (instance2 != null)
				{
					PhotonView photonView2 = instance2.photonView;
					if (photonView2 != null)
					{
						photonView2.RPC("SyncChallengeRPC", (RpcTarget)0, new object[1] { num7 });
					}
				}
			}
			else
			{
				LevelStatsSyncing.instance?.SyncChallengeRPC(num7);
			}
		}

		public static void SetupChallenges(ChallengeType challenge)
		{
			currentChallenges.Clear();
			if (Plugin.DeepLog)
			{
				Helpers.DeepLog($"[ChallengeManager] selected challenge: {challenge}");
			}
			if (challenge != 0)
			{
				currentChallenges.Add(challenge);
			}
		}
	}
	public class Helpers
	{
		public enum RoundingOptions
		{
			Floor,
			Round,
			Ceil
		}

		public static PlayerChatBoxState truckScreenState = (PlayerChatBoxState)0;

		private static readonly Dictionary<int, Color> difficultyColors = new Dictionary<int, Color>
		{
			{
				2147483639,
				new Color(0f, 0f, 0f)
			},
			{
				999,
				new Color(0f, 0f, 0f)
			},
			{
				100,
				new Color(0.2f, 0.2f, 0.2f)
			},
			{
				90,
				new Color(0f, 1f, 0.5f)
			},
			{
				80,
				new Color(0f, 1f, 1f)
			},
			{
				70,
				new Color(0f, 0.5f, 1f)
			},
			{
				60,
				new Color(0f, 0f, 1f)
			},
			{
				50,
				new Color(0.5f, 0f, 1f)
			},
			{
				40,
				new Color(1f, 0f, 1f)
			},
			{
				30,
				new Color(1f, 0f, 0.5f)
			},
			{
				20,
				new Color(1f, 0f, 0f)
			},
			{
				15,
				new Color(1f, 0.5f, 0f)
			},
			{
				10,
				new Color(1f, 1f, 0f)
			},
			{
				5,
				new Color(0.5f, 1f, 0f)
			},
			{
				1,
				new Color(0f, 1f, 0f)
			}
		};

		public static int PlayerCount => GameDirector.instance.PlayerList.Count;

		public static bool TruckStarting => (int)truckScreenState == 3;

		public static bool TruckLeaving
		{
			get
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				if ((int)truckScreenState != 2)
				{
					return TruckStarting;
				}
				return true;
			}
		}

		public static int CurrentLevel => LevelGeneratorPatch.CurrentLevel;

		public static ExtractionPoint ExtractionPointCurrent => Traverse.Create((object)RoundDirector.instance).Field("extractionPointCurrent").GetValue<ExtractionPoint>();

		public static int ExtractionHaulGoal => Traverse.Create((object)RoundDirector.instance).Field("extractionHaulGoal").GetValue<int>();

		public static bool AllExtractionPointsCompleted => Traverse.Create((object)RoundDirector.instance).Field("allExtractionPointsCompleted").GetValue<bool>();

		public static int Round(float number, RoundingOptions options, int factor = 1)
		{
			switch (options)
			{
			case RoundingOptions.Floor:
				number = Mathf.Floor(number / (float)factor);
				break;
			case RoundingOptions.Round:
				number = Mathf.Round(number / (float)factor);
				break;
			case RoundingOptions.Ceil:
				number = Mathf.Ceil(number / (float)factor);
				break;
			}
			return (int)(number * (float)factor);
		}

		public static int RoundClamp(float number, RoundingOptions options, int min, int max, int factor = 1)
		{
			return Mathf.Clamp(Round(number, options, factor), min, max);
		}

		public static void DebugForceLoadLevel(int level, ChallengeManager.ChallengeType forcedChallenge = ChallengeManager.ChallengeType.None)
		{
			RunManager.instance.levelsCompleted = level - 1;
			ChallengeManager.forceChallenge = forcedChallenge;
			RunManager.instance.ChangeLevel(true, false, (ChangeLevelType)1);
		}

		public static string TimeToString(float seconds)
		{
			seconds = Mathf.Clamp(seconds, 0f, 360000f);
			int num = (int)(seconds * 1000f) % 1000;
			int num2 = (int)seconds % 60;
			int num3 = (int)(seconds / 60f) % 60;
			int num4 = (int)(seconds / 3600f);
			return $"{num4:00}:{num3:00}:{num2:00}<size=75%>.{num:000}</size>";
		}

		public static Color GetDifficultyColor(int level)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color.black;
			int num = 0;
			foreach (KeyValuePair<int, Color> difficultyColor in difficultyColors)
			{
				if (level >= difficultyColor.Key)
				{
					float num2 = (float)(level - difficultyColor.Key) / (float)(num - difficultyColor.Key);
					return Color.Lerp(difficultyColor.Value, val, num2);
				}
				val = difficultyColor.Value;
				num = difficultyColor.Key;
			}
			return new Color(0f, 0f, 0f);
		}

		public static string ColoredText(string text, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text2 = ColorUtility.ToHtmlStringRGB(color);
			return ColoredText(text, "#" + text2);
		}

		public static string ColoredText(string text, string hexColor)
		{
			return "<color=" + hexColor + ">" + text + "</color>";
		}

		public static string PlusMinus(int number)
		{
			if (number < 0)
			{
				return number.ToString();
			}
			if (number > 0)
			{
				return $"+{number}";
			}
			return $"±{number}";
		}

		public static string PlusMinus(float number)
		{
			if (number < 0f)
			{
				return $"{number:0.00}";
			}
			if (number > 0f)
			{
				return $"+{number:0.00}";
			}
			return $"±{number:0.00}";
		}

		public static float RoundTo100(float original)
		{
			return Mathf.Round(original / 100f) * 100f;
		}

		public static void DeepLog(string log)
		{
			if (Plugin.DeepLogging.Value)
			{
				Plugin.loggy.LogDebug((object)log);
			}
		}

		public static float RGDM1(int level)
		{
			return Mathf.Clamp01(((float)level - 1f) / 9f);
		}

		public static float RGDM2(int level)
		{
			return Mathf.Clamp01(((float)level - 10f) / 10f);
		}

		public static float RGDM3(int level)
		{
			return Mathf.Clamp01(((float)level - 20f) / 10f);
		}

		public static T GetConfig<T>(ConfigEntry<T> config)
		{
			return (T)(MalfunctionManager.IsMalfunctionActive() ? ((ConfigEntryBase)config).DefaultValue : ((object)config.Value));
		}

		public static bool AllPlayersDead()
		{
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				if (!player.isDisabled)
				{
					return false;
				}
			}
			return true;
		}
	}
	public class MalfunctionManager
	{
		public enum MalfunctionType
		{
			None,
			QuotaDifficulty,
			LowMapValue,
			RandomLevelSize,
			SingleExtraction,
			RandomValuableValue,
			E10_10_10,
			MaxModeEasy,
			MaxMode,
			Soulstealers
		}

		public class Malfunction
		{
			public MalfunctionType type;

			public string name;

			public string[] infoLines;

			public Malfunction(MalfunctionType type, string name, string info)
			{
				this.type = type;
				this.name = name;
				infoLines = info.Split(new char[1] { '/' });
			}
		}

		[CompilerGenerated]
		private sealed class <Solitude_TimesUp>d__46 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <Solitude_TimesUp>d__46(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00de: 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_008d: 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)
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				_solitude_ShownWarning = byte.MaxValue;
				if ((Object)(object)Helpers.ExtractionPointCurrent == (Object)null)
				{
					return false;
				}
				if (!SemiFunc.IsMasterClientOrSingleplayer() || _solitudeCompletedSequence || _solitudeGameOverSequence)
				{
					return false;
				}
				if (SolitudeQuotaMet)
				{
					if (GameManager.Multiplayer() && SemiFunc.IsMasterClient())
					{
						LevelStatsSyncing instance = LevelStatsSyncing.instance;
						if (instance != null)
						{
							PhotonView photonView = instance.photonView;
							if (photonView != null)
							{
								photonView.RPC("Solitude_CompleteRPC", (RpcTarget)0, Array.Empty<object>());
							}
						}
						return false;
					}
					LevelStatsSyncing.instance?.Solitude_CompleteRPC();
					return false;
				}
				if (GameManager.Multiplayer() && SemiFunc.IsMasterClient())
				{
					LevelStatsSyncing instance2 = LevelStatsSyncing.instance;
					if (instance2 != null)
					{
						PhotonView photonView2 = instance2.photonView;
						if (photonView2 != null)
						{
							photonView2.RPC("Solitude_KillSelfRPC", (RpcTarget)0, Array.Empty<object>());
						}
					}
					return false;
				}
				LevelStatsSyncing.instance?.Solitude_KillSelfRPC();
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static bool malfunctionSetThisSave = false;

		public static List<MalfunctionType> _whitelistedMalfunctions = new List<MalfunctionType>();

		public static MalfunctionType selectedMalfunction = MalfunctionType.None;

		public static MalfunctionType activeMalfunction = MalfunctionType.None;

		public static readonly Dictionary<MalfunctionType, int> bestMalfunctionLevels = new Dictionary<MalfunctionType, int>();

		public static readonly List<Malfunction> allMalfunctions = new List<Malfunction>
		{
			new Malfunction(MalfunctionType.QuotaDifficulty, "Perfectionist", "• Quota difficulty starts at 0.7/• Difficulty will rise linearly/• Caps at 0.99 at Level 20/• Challenges appear every level"),
			new Malfunction(MalfunctionType.LowMapValue, "Sparsity", "• All maps have 3x less value/• Valuable limit is significantly lower/• Levels are larger/• Levels have less extraction points"),
			new Malfunction(MalfunctionType.RandomLevelSize, "Oscillation", "• Each map is either very tiny or super large/• Map size does not scale with level number/• Map size is determined randomly every level/• +2% walk speed & stamina regen speed per module explored/    *Resets every level"),
			new Malfunction(MalfunctionType.SingleExtraction, "Solitude", "• There is only one extraction point every level/• All maps are 20% smaller/• Valuables in the extraction point will not have gravity/• Quotas have two \"stages\", completing stage 2 will extract immediately/• Extraction will occur automatically after a set time, immediately lose if/if you don't meet the stage 1 quota at the time limit./• Time starts at 5 min, then +5 min at each moon phase/• -1 sec per $500 broken during a level/• -10 sec (permanently) per additional team member (up to -60)/• +15 sec per orb dropped from an enemy/• +5 sec per enemy killed/• Players are auto-revived if there's at least 1:30 on the clock/• -75 sec per player revived"),
			new Malfunction(MalfunctionType.RandomValuableValue, "Arbitrarity", "• Valuable values are randomized/• Small valuables are more likely to be cheap & vice versa/• Each valuable's mass is randomized/• Any valuable size can appear on any level/• Enemy strength breakpoints are randomized"),
			new Malfunction(MalfunctionType.E10_10_10, "Formidable", "• Start with 1 enemy of each tier/• Each level adds 1 enemy of each tier/• Caps at 10 enemies per tier after level 10/• Enemies have half health/• Enemies cannot be grabstunned outside Enemy Rush/• Players take 50% less damage"),
			new Malfunction(MalfunctionType.Soulstealers, "Soulstealers", "• All valuables are $30 or less and explode when broken/• Heavier valuables create a stronger explosion/• Enemy orbs are unlimited and worth 50% more/• All enemies will drop orbs even if they normally don't/• All enemies will respawn 5x faster/• Enemies will immediately respawn after each extraction/• Players will now be revived when brought near soul orbs/  • The larger the orb, the faster the respawn/  • If the orb breaks early, the respawn is cancelled/  • Extraction points will no longer revive players/  • When the respawn completes, the orb is destroyed/• Enemies gain +10% max health every 5 levels (up to +100%)"),
			new Malfunction(MalfunctionType.MaxModeEasy, "Grandmaster", "• All settings are overtuned/• Scaling is linear from level 1 to 100/• Good luck."),
			new Malfunction(MalfunctionType.MaxMode, "Max Mode", "• All settings are maxed out, no exceptions/• Each level is the same, no difficulty scaling/• Not meant to be possible./• Your game might lag.")
		};

		public static ParticleScriptExplosion soulstealerExplosion;

		public static Dictionary<PlayerAvatar, float> solitudeDeathTimers = new Dictionary<PlayerAvatar, float>();

		public static int solitudeRevives = 0;

		public static int _lastSolitudeSecondsRemoved = 0;

		public static byte _solitude_ShownWarning = 0;

		public static Coroutine _solitude_timesUpSequence;

		public static bool _solitudeGameOverSequence = false;

		public static bool _solitudeCompletedSequence = false;

		public static float SolitudeTimeLimitSeconds
		{
			get
			{
				int num = GameDirector.instance.PlayerList.Count switch
				{
					1 => 0, 
					2 => -10, 
					3 => -20, 
					4 => -30, 
					5 => -40, 
					_ => -60, 
				};
				float num2 = Mathf.Clamp(Mathf.Floor((float)Helpers.CurrentLevel / 5f) + 1f, 1f, 5f);
				return (300f + (float)num) * num2;
			}
		}

		public static int SolitudeSecondsRemovedBroken => (int)(LevelStatsManager.totalValueBroken / 500f);

		public static int SolitudeSecondsAddedOrbs => LevelStatsManager.enemyKills * 15;

		public static int SolitudeSecondsAddedKills => LevelStatsManager.enemyKillsRaw * 5;

		public static int SolitudeSecondsRemovedRevives => solitudeRevives * 75;

		public static float SolitudeTimeRemainingSeconds => Mathf.Clamp(SolitudeTimeLimitSeconds - LevelStatsManager.thisLevelTime - (float)SolitudeSecondsRemovedBroken - (float)SolitudeSecondsRemovedRevives + (float)SolitudeSecondsAddedOrbs + (float)SolitudeSecondsAddedKills, 0f, 5999f);

		public static int SolitudeRequiredQuota
		{
			get
			{
				float num = Mathf.Lerp(0.25f, 0.7f, Mathf.InverseLerp(1f, 20f, (float)Helpers.CurrentLevel));
				return (int)((float)Helpers.ExtractionHaulGoal * num);
			}
		}

		public static bool SolitudeQuotaMet => Traverse.Create((object)Helpers.ExtractionPointCurrent).Field("haulCurrent").GetValue<int>() >= SolitudeRequiredQuota;

		public static void Setup()
		{
			_whitelistedMalfunctions.Clear();
			_whitelistedMalfunctions.Add(MalfunctionType.RandomValuableValue);
			_whitelistedMalfunctions.Add(MalfunctionType.RandomLevelSize);
			_whitelistedMalfunctions.Add(MalfunctionType.QuotaDifficulty);
			_whitelistedMalfunctions.Add(MalfunctionType.LowMapValue);
			_whitelistedMalfunctions.Add(MalfunctionType.SingleExtraction);
			if (!Plugin.Compatibility_SpawnConfig)
			{
				_whitelistedMalfunctions.Add(MalfunctionType.E10_10_10);
				_whitelistedMalfunctions.Add(MalfunctionType.Soulstealers);
				_whitelistedMalfunctions.Add(MalfunctionType.MaxModeEasy);
				_whitelistedMalfunctions.Add(MalfunctionType.MaxMode);
			}
		}

		public static bool IsMalfunctionActive()
		{
			if (activeMalfunction != 0 && SemiFunc.RunIsLevel())
			{
				return Plugin.LSCompatibilityMode.Value == Plugin.CompatibilityMode.None;
			}
			return false;
		}

		public static bool IsMalfunctionActive(MalfunctionType type)
		{
			if (activeMalfunction == type && SemiFunc.RunIsLevel())
			{
				return Plugin.LSCompatibilityMode.Value == Plugin.CompatibilityMode.None;
			}
			return false;
		}

		public static Malfunction GetMalfunction(MalfunctionType type)
		{
			foreach (Malfunction allMalfunction in allMalfunctions)
			{
				if (allMalfunction.type == type)
				{
					return allMalfunction;
				}
			}
			return new Malfunction(MalfunctionType.None, "????????", "N/A");
		}

		public static void SelectMalfunction(MalfunctionType type)
		{
			selectedMalfunction = type;
			if (SemiFunc.IsMainMenu())
			{
				SetMalfunction(type);
			}
			else if (SemiFunc.RunIsLobbyMenu() && SemiFunc.IsMasterClientOrSingleplayer())
			{
				SyncMalfunction(type);
			}
		}

		public static void SyncMalfunction()
		{
			if (SemiFunc.IsMasterClientOrSingleplayer())
			{
				SyncMalfunction(activeMalfunction);
			}
		}

		public static void SyncMalfunction(MalfunctionType type)
		{
			//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)
			if (Plugin.LSCompatibilityMode.Value <= Plugin.CompatibilityMode.Host || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			if (GameManager.Multiplayer())
			{
				LevelStatsSyncing instance = LevelStatsSyncing.instance;
				if (instance != null)
				{
					instance.photonView.RPC("SyncMalfunctionRPC", (RpcTarget)0, new object[1] { (int)type });
				}
			}
			else
			{
				LevelStatsSyncing.instance?.SyncMalfunctionRPC((int)type);
			}
		}

		public static void SetMalfunction(MalfunctionType type, bool withNotification = false)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.LSCompatibilityMode.Value <= Plugin.CompatibilityMode.Host)
			{
				selectedMalfunction = MalfunctionType.None;
				return;
			}
			if (activeMalfunction != type && withNotification)
			{
				string text = GetMalfunction(type).name.ToUpper();
				if (type == MalfunctionType.None)
				{
					SwaggiFunc.DisplayBigMessage("MALFUNCTION DISABLED", "{!}", 3f, new Color(0.5f, 0.5f, 0.5f), Color.red);
				}
				else
				{
					SwaggiFunc.DisplayBigMessage("<size=36>" + text + "</size>\nMALFUNCTION ACTIVE!", "{!}", 3f, new Color(0.5f, 0f, 1f), Color.red);
				}
			}
			activeMalfunction = type;
		}

		public static void SetMalfunctionBestLevel(MalfunctionType type, int level, bool allowBelow = false, bool force = false)
		{
			if (!force && Plugin.LSCompatibilityMode.Value <= Plugin.CompatibilityMode.Host)
			{
				return;
			}
			if (bestMalfunctionLevels.ContainsKey(type))
			{
				int value = level;
				if (!allowBelow)
				{
					value = Mathf.Max(level, bestMalfunctionLevels[type]);
				}
				bestMalfunctionLevels[type] = value;
			}
			else
			{
				bestMalfunctionLevels.Add(type, level);
			}
		}

		public static int GetMalfunctionBestLevel(MalfunctionType type)
		{
			if (bestMalfunctionLevels.ContainsKey(type))
			{
				return bestMalfunctionLevels[type];
			}
			return 0;
		}

		public static bool IsLevelLargeMap(int level, bool withoutRandomness = false)
		{
			if (withoutRandomness)
			{
				return level % 2 == 0;
			}
			if (level == 1)
			{
				return false;
			}
			return new Random(ChallengeManager.CurrentSeed + 88266 + level).Next(0, 2) == 1;
		}

		public static int Formidable_EnemiesThisLevel(int level)
		{
			return Mathf.Clamp(level, 1, 10);
		}

		public static void Solitude_HandleTimer()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Invalid comparison between Unknown and I4
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Invalid comparison between Unknown and I4
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Invalid comparison between Unknown and I4
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Invalid comparison between Unknown and I4
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Invalid comparison between Unknown and I4
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Invalid comparison between Unknown and I4
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Invalid comparison between Unknown and I4
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			if (!SemiFunc.RunIsLevel() || Plugin.LSCompatibilityMode.Value <= Plugin.CompatibilityMode.Host || !IsMalfunctionActive(MalfunctionType.SingleExtraction))
			{
				return;
			}
			Solitude_HandleDeadPlayers();
			ExtractionPoint extractionPointCurrent = Helpers.ExtractionPointCurrent;
			if ((Object)(object)extractionPointCurrent == (Object)null)
			{
				return;
			}
			State value = Traverse.Create((object)extractionPointCurrent).Field("currentState").GetValue<State>();
			if (SolitudeTimeRemainingSeconds <= 0f && _solitude_ShownWarning < 100)
			{
				Solitude_TimerOut(value);
			}
			if (_solitude_ShownWarning < 100)
			{
				if ((int)value == 2 || (int)value == 3)
				{
					extractionPointCurrent.haulGoal = Mathf.Max(SolitudeRequiredQuota + 1, LevelStatsManager.RemainingTotalMapValue);
				}
				if ((int)value == 4 || (int)value == 6)
				{
					int value2 = Traverse.Create((object)extractionPointCurrent).Field("haulCurrent").GetValue<int>();
					extractionPointCurrent.haulGoal = Mathf.Max(extractionPointCurrent.haulGoal, value2);
					Traverse.Create((object)RoundDirector.instance).Field("extractionHaulGoal").SetValue((object)value2);
				}
			}
			if ((int)value == 6 || (int)value == 9 || (int)value == 7)
			{
				return;
			}
			if (_lastSolitudeSecondsRemoved != SolitudeSecondsRemovedBroken)
			{
				GoalUIPatch.FlashRed();
				_lastSolitudeSecondsRemoved = SolitudeSecondsRemovedBroken;
			}
			int num = Mathf.CeilToInt(SolitudeTimeRemainingSeconds);
			if (SolitudeTimeRemainingSeconds <= 10f && _solitude_ShownWarning < 20 - num)
			{
				if (num == 1)
				{
					SwaggiFunc.DisplayBigMessage($"{num} SECOND LEFT!", "{clock}", 1f, Color.red, Color.yellow);
				}
				else
				{
					SwaggiFunc.DisplayBigMessage($"{num} SECONDS LEFT!", "{clock}", 1f, Color.red, Color.yellow);
				}
				_solitude_ShownWarning = (byte)(20 - num);
			}
			else if (SolitudeTimeRemainingSeconds <= 60f && _solitude_ShownWarning <= 2)
			{
				SwaggiFunc.DisplayBigMessage("1 MINUTE LEFT!", "{clock}", 4f, Color.red, Color.yellow);
				_solitude_ShownWarning = 3;
			}
			else if (SolitudeTimeRemainingSeconds <= 300f && _solitude_ShownWarning <= 1)
			{
				if (SolitudeTimeLimitSeconds > 300f)
				{
					SwaggiFunc.DisplayBigMessage("5 MINUTES LEFT!", "{clock}", 4f, Color.yellow, Color.white);
				}
				_solitude_ShownWarning = 2;
			}
			else if (SolitudeTimeRemainingSeconds <= 600f && _solitude_ShownWarning <= 0)
			{
				if (SolitudeTimeLimitSeconds > 600f)
				{
					SwaggiFunc.DisplayBigMessage("10 MINUTES LEFT!", "{clock}", 4f, Color.yellow, Color.white);
				}
				_solitude_ShownWarning = 1;
			}
		}

		public static void Solitude_TimerOut(State state)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0021: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (_solitude_ShownWarning >= 100)
			{
				return;
			}
			if ((int)state != 2)
			{
				if ((int)state != 6)
				{
					SwaggiFunc.DisplayBigMessage("EXTRACTION STALLED", "{clock}", 0.2f, Color.red, Color.yellow);
				}
				return;
			}
			_solitude_ShownWarning = 100;
			if (GameManager.Multiplayer() && SemiFunc.IsMasterClient())
			{
				LevelStatsSyncing instance = LevelStatsSyncing.instance;
				if (instance != null)
				{
					PhotonView photonView = instance.photonView;
					if (photonView != null)
					{
						photonView.RPC("Solitude_TimesUpSequenceRPC", (RpcTarget)0, Array.Empty<object>());
					}
				}
			}
			else
			{
				LevelStatsSyncing.instance?.Solitude_TimesUpSequenceRPC();
			}
		}

		[IteratorStateMachine(typeof(<Solitude_TimesUp>d__46))]
		public static IEnumerator Solitude_TimesUp()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Solitude_TimesUp>d__46(0);
		}

		public static void Solitude_KillSelf()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			SwaggiFunc.DisplayBigMessage("NOT ENOUGH VALUABLES,\nTRY HARDER NEXT TIME.", "{!}", 4f, Color.white, Color.red);
			if (!Traverse.Create((object)PlayerAvatar.instance).Field("isDisabled").GetValue<bool>())
			{
				PlayerAvatar.instance.PlayerDeath(-1);
			}
		}

		public static bool Solitude_ShouldRevivePlayer()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Invalid comparison between Unknown and I4
			if (Helpers.AllExtractionPointsCompleted)
			{
				return false;
			}
			ExtractionPoint extractionPointCurrent = Helpers.ExtractionPointCurrent;
			if ((Object)(object)extractionPointCurrent != (Object)null)
			{
				if (_solitudeGameOverSequence)
				{
					return false;
				}
				if (_solitudeCompletedSequence)
				{
					return true;
				}
				if ((int)Traverse.Create((object)extractionPointCurrent).Field("currentState").GetValue<State>() != 2)
				{
					return true;
				}
				return SolitudeTimeRemainingSeconds > 90f;
			}
			return false;
		}

		public static void Solitude_RevivePlayer(PlayerAvatar player)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player.playerDeathHead == (Object)null || !Traverse.Create((object)player).Field("isDisabled").GetValue<bool>() || !SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			Helpers.DeepLog("[Solitude] Reviving player!");
			PhysGrabObject value = Traverse.Create((object)player.playerDeathHead).Field("physGrabObject").GetValue<PhysGrabObject>();
			if (solitudeDeathTimers[player] < 40f)
			{
				if (value.playerGrabbing.Count > 0)
				{
					return;
				}
				Vector3 velocity = value.rb.velocity;
				if (((Vector3)(ref velocity)).magnitude > 0.01f)
				{
					return;
				}
			}
			player.Revive(false);
			if (GameManager.Multiplayer() && SemiFunc.IsMasterClient())
			{
				LevelStatsSyncing instance = LevelStatsSyncing.instance;
				if (instance != null)
				{
					PhotonView photonView = instance.photonView;
					if (photonView != null)
					{
						photonView.RPC("Solitude_PlayerRevivedRPC", (RpcTarget)0, Array.Empty<object>());
					}
				}
			}
			else
			{
				LevelStatsSyncing.instance?.Solitude_PlayerRevivedRPC();
			}
		}

		private static void Solitude_HandleDeadPlayers()
		{
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				if (!Traverse.Create((object)player).Field("isDisabled").GetValue<bool>())
				{
					if (solitudeDeathTimers.ContainsKey(player))
					{
						solitudeDeathTimers.Remove(player);
					}
				}
				else if (!solitudeDeathTimers.ContainsKey(player))
				{
					solitudeDeathTimers.Add(player, 0f);
				}
			}
			foreach (PlayerAvatar item in solitudeDeathTimers.Keys.ToList())
			{
				if (solitudeDeathTimers[item] >= 10f)
				{
					Solitude_RevivePlayer(item);
				}
			}
			if (!Solitude_ShouldRevivePlayer() || Helpers.AllExtractionPointsCompleted)
			{
				return;
			}
			foreach (PlayerAvatar item2 in solitudeDeathTimers.Keys.ToList())
			{
				solitudeDeathTimers[item2] += Time.deltaTime;
			}
		}
	}
	[HarmonyPatch(typeof(ExtractionPoint))]
	internal class ExtractionPointPatch
	{
		private static int TotalMapValueAtStartOfRound;

		[HarmonyPatch("HaulGoalSet")]
		[HarmonyPrefix]
		private static void HaulGoalSetPrefix(ref int value)
		{
			int haulGoalMax = RoundDirector.instance.haulGoalMax;
			int extractionPoints = RoundDirector.instance.extractionPoints;
			int extractionPointsCompleted = RoundDirector.instance.extractionPointsCompleted;
			if (extractionPointsCompleted == 0)
			{
				TotalMapValueAtStartOfRound = haulGoalMax;
			}
			float num = 1f;
			if (Helpers.GetConfig<bool>(Plugin.Modify_HaulGoal) && Plugin.LSCompatibilityMode.Value > Plugin.CompatibilityMode.Client)
			{
				num = SwaggiFunc.DetermineBaseQuotaDifficulty(Helpers.CurrentLevel);
				if (MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.SingleExtraction))
				{
					num *= 1.2f;
				}
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.HighQuota))
			{
				float num2 = Mathf.Abs(1f - num);
				num += Mathf.Clamp(num2 / 2f, 0.05f, 0.4f);
			}
			if (Helpers.GetConfig<bool>(Plugin.Modify_HaulGoal))
			{
				value = SwaggiFunc.DetermineQuota(extractionPointsCompleted, extractionPoints, TotalMapValueAtStartOfRound, num);
			}
			else
			{
				value = Mathf.RoundToInt((float)value * num);
			}
			if (Plugin.DeepLog)
			{
				Helpers.DeepLog("[ExtractionPoint HaulGoalSet]\n" + $"total map value = {haulGoalMax:n0}\n" + $"extractions     = {extractionPoints} / {extractionPointsCompleted}\n" + $"difficulty      = {num:0.000}\n" + $"final quota     = {value:n0}");
			}
		}

		[HarmonyPatch("ActivateTheFirstExtractionPointAutomaticallyWhenAPlayerLeaveTruck")]
		[HarmonyPostfix]
		private static void ActivateTheFirstExtractionPointAutomaticallyWhenAPlayerLeaveTruckP()
		{
			LevelStatsManager.firstExtractionOpenedThisLevel = true;
		}

		[HarmonyPatch("DestroyTheFirstPhysObjectsInHaulList")]
		[HarmonyPrefix]
		private static void DestroyTheFirstPhysObjectsInHaulListP()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer() || RoundDirector.instance.dollarHaulList.Count == 0 || !Object.op_Implicit((Object)(object)RoundDirector.instance.dollarHaulList[0]))
			{
				return;
			}
			ValuableObject component = RoundDirector.instance.dollarHaulList[0].GetComponent<ValuableObject>();
			SurplusValuable component2 = RoundDirector.instance.dollarHaulList[0].GetComponent<SurplusValuable>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (!Traverse.Create((object)component).Field("discovered").GetValue<bool>())
				{
					LevelStatsManager.nonDiscoveredValuablesBroken++;
				}
				float value = Traverse.Create((object)component).Field("dollarValueCurrent").GetValue<float>();
				SwaggiFunc.SharedDurability_HealAllPlayers(value, value >= 10000f);
				if (!Object.op_Implicit((Object)(object)component2))
				{
					LevelStatsManager.AddValueExtracted(value);
					RunStatsManager.instance.totalValueExtracted += value;
				}
			}
		}

		[HarmonyPatch("DestroyAllPhysObjectsInHaulList")]
		[HarmonyPrefix]
		private static void DestroyAllPhysObjectsInHaulListP()
		{
			GlobalStatsManager.AddExtractionCompleted();
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			float num = 0f;
			foreach (GameObject dollarHaul in RoundDirector.instance.dollarHaulList)
			{
				ValuableObject component = dollarHaul.GetComponent<ValuableObject>();
				SurplusValuable component2 = dollarHaul.GetComponent<SurplusValuable>();
				if (Object.op_Implicit((Object)(object)component))
				{
					if (!Traverse.Create((object)component).Field("discovered").GetValue<bool>())
					{
						LevelStatsManager.nonDiscoveredValuablesBroken++;
					}
					float value = Traverse.Create((object)component).Field("dollarValueCurrent").GetValue<float>();
					num += value;
					if (!Object.op_Implicit((Object)(object)component2))
					{
						LevelStatsManager.AddValueExtracted(value);
					}
				}
			}
			SwaggiFunc.SharedDurability_HealAllPlayers(num, forceHealEffect: true);
			if (SemiFunc.RunIsLevel())
			{
				RunStatsManager.instance.extractionPointsCompleted++;
			}
			if (MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.SingleExtraction))
			{
				foreach (PlayerAvatar item in MalfunctionManager.solitudeDeathTimers.Keys.ToList())
				{
					MalfunctionManager.solitudeDeathTimers[item] = 999f;
				}
			}
			if (!MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.Soulstealers))
			{
				return;
			}
			foreach (EnemyParent item2 in EnemyDirector.instance.enemiesSpawned)
			{
				item2.DespawnedTimerSet(Random.Range(5f, 65f), true);
			}
		}

		[HarmonyPatch("SpawnTaxReturn")]
		[HarmonyPrefix]
		private static void SpawnTaxReturnP()
		{
			int value = Traverse.Create((object)RoundDirector.instance).Field("extractionPointSurplus").GetValue<int>();
			if (value > 0)
			{
				LevelStatsManager._valueFromSurplus += value;
				RunStatsManager.instance.largestSurplusValue = Mathf.Max(value, RunStatsManager.instance.largestSurplusValue);
				GlobalStatsManager.SetLargestSurplusValue(value);
			}
		}

		[HarmonyPatch("SetHaulText")]
		[HarmonyPostfix]
		private static void SetHaulTextP(ref ExtractionPoint __instance, ref bool ___isShop, ref float ___haulBarTargetScale)
		{
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.HiddenInformation) && Plugin.LSCompatibilityMode.Value > Plugin.CompatibilityMode.Host && !___isShop)
			{
				((TMP_Text)__instance.haulGoalScreen).text = "<color=#bd4300>$</color>?????";
				___haulBarTargetScale = 1f;
				Traverse.Create((object)__instance).Method("SetEmojiScreen", new object[2] { "<sprite name=:)>", false }).GetValue();
			}
		}

		[HarmonyPatch("CancelExtraction")]
		[HarmonyPrefix]
		private static bool CancelExtractionP(ref ExtractionPoint __instance, ref int ___haulCurrent)
		{
			if (!MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.SingleExtraction))
			{
				return true;
			}
			if (!SemiFunc.RunIsLevel())
			{
				return true;
			}
			if (MalfunctionManager._solitude_ShownWarning != byte.MaxValue)
			{
				return true;
			}
			int value = Traverse.Create((object)RoundDirector.instance).Field("currentHaul").GetValue<int>();
			Traverse.Create((object)RoundDirector.instance).Field("extractionHaulGoal").SetValue((object)value);
			__instance.haulGoal = value;
			___haulCurrent = value;
			return false;
		}
	}
	[HarmonyPatch(typeof(LevelGenerator))]
	internal class LevelGeneratorPatch
	{
		public static int modulesSpawned;

		public static int modulesTotal;

		public static int CurrentLevel => RunManager.instance.levelsCompleted + 1;

		public static int CurrentModCount => Traverse.Create((object)LevelGenerator.Instance).Field("ModuleAmount").GetValue<int>();

		public static int CurrentExtCount => Traverse.Create((object)LevelGenerator.Instance).Field("ExtractionAmount").GetValue<int>();

		[HarmonyPatch("GenerateDone")]
		[HarmonyPostfix]
		private static void GenerateDoneP()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (!((Object)(object)MalfunctionManager.soulstealerExplosion != (Object)null))
			{
				ParticleScriptExplosion component = Resources.Load<GameObject>("Items/Item Grenade Explosive").GetComponent<ParticleScriptExplosion>();
				GameObject val = new GameObject("LS_PSE");
				Object.DontDestroyOnLoad((Object)val);
				ParticleScriptExplosion obj = val.AddComponent<ParticleScriptExplosion>();
				obj.explosionPrefab = component.explosionPrefab;
				obj.explosionPreset = component.explosionPreset;
				MalfunctionManager.soulstealerExplosion = obj;
			}
		}

		[HarmonyPatch("SpawnModule")]
		[HarmonyPostfix]
		private static void SpawnModuleP()
		{
			modulesSpawned++;
		}

		[HarmonyPatch("ModuleGeneration")]
		[HarmonyPrefix]
		private static void ModuleGenerationP(ref LevelGenerator __instance, ref Tile[,] ___LevelGrid)
		{
			modulesTotal = 0;
			for (int i = 0; i < __instance.LevelWidth; i++)
			{
				for (int j = 0; j < __instance.LevelHeight; j++)
				{
					if (___LevelGrid[i, j].active)
					{
						modulesTotal++;
					}
				}
			}
		}

		private static int GetNewModuleCount()
		{
			if (!SemiFunc.RunIsLevel())
			{
				return CurrentModCount;
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.HiddenInformation))
			{
				return Random.Range(5, 9);
			}
			int num = CurrentModCount;
			if (Helpers.GetConfig<bool>(Plugin.Modify_ModuleCount) && Plugin.LSCompatibilityMode.Value > Plugin.CompatibilityMode.Client)
			{
				num = SwaggiFunc.DetermineNumberOfModules(CurrentLevel, GameDirector.instance.PlayerList.Count, RunManager.instance.levelCurrent.NarrativeName);
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.LargeMap))
			{
				num += Mathf.Clamp(Mathf.RoundToInt((float)num * 0.4f), 6, 12);
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.FoggyLevel))
			{
				num = Mathf.Max(3, Mathf.CeilToInt((float)num / 2.33f));
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.NoMap))
			{
				num = Mathf.Max(3, Mathf.RoundToInt((float)num * 0.9f));
			}
			if (Plugin.DeepLog)
			{
				Helpers.DeepLog($"[ModuleCount] {num}");
			}
			return num;
		}

		private static int GetNewExtractionCount()
		{
			if (!SemiFunc.RunIsLevel())
			{
				return CurrentExtCount;
			}
			int num = CurrentExtCount;
			if (Helpers.GetConfig<bool>(Plugin.Modify_ExtractionCount) && Plugin.LSCompatibilityMode.Value > Plugin.CompatibilityMode.Client)
			{
				num = SwaggiFunc.DetermineNumberOfExtractions(CurrentLevel, GameDirector.instance.PlayerList.Count);
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.HiddenInformation))
			{
				num = Random.Range(1, 3);
			}
			if (ChallengeManager.IsChallengeActive(ChallengeManager.ChallengeType.LargeMap))
			{
				num++;
			}
			if (MalfunctionManager.IsMalfunctionActive(MalfunctionManager.MalfunctionType.SingleExtraction))
			{
				num = 0;
			}
			if (Plugin.DeepLog)
			{
				Helpers.DeepLog($"[ExtractionCount] {num}");
			}
			return num;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TileGenerationTranspiler(IEnumerable<CodeInstruction> inst)
		{
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(inst);
			if (list.Count <= 20)
			{
				Plugin.loggy.LogError((object)"Less than 20 instructions were found in TileGeneration, this is abnormal.");
				return list;
			}
			int num = -1;
			for (int i = 3; i < list.Count - 1; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && (FieldInfo)list[i].operand == AccessTools.Field(typeof(LevelGenerator), "ModuleAmount") && list[i + 1].opcode == OpCodes.Ldc_I4_3)
				{
					num = i - 3;
					break;
				}
			}
			if (num == -1)
			{
				Plugin.loggy.LogError((object)"Never found an insertion point for ModuleCount, unable to patch TileGeneration.");
				return list;
			}
			int num2 = -1;
			for (int j = 1; j < list.Count - 1; j++)
			{
				if (list[j].opcode == OpCodes.Ldarg_0 && list[j + 1].opcode == OpCodes.Ldc_I4_M1 && list[j + 4].opcode == OpCodes.Ldfld && (FieldInfo)list[j + 4].operand == AccessTools.Field(typeof(LevelGenerator), "ExtractionAmount"))
				{
					num2 = j - 1;
					break;
				}
			}
			if (num2 == -1)
			{
				Plugin.loggy.LogError((object)"Never found an insertion point for ExtractionCount, unable to patch TileGeneration.");
				return list;
			}
			List<CodeInstruction> collection = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(LevelGeneratorPatch), "GetNewModuleCount", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(LevelGenerator), "ModuleAmount"))
			};
			List<CodeInstruction> collection2 = new List<CodeInstruction>
			{
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(LevelGeneratorPatch), "GetNewExtractionCount", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(LevelGenerator), "ExtractionAmount"))
			};
			list.InsertRange(num2, collection2);
			list.InsertRange(num, collection);
			return list;
		}

		[HarmonyPatch("Generate")]
		[HarmonyPrefix]
		private static void GenerateP()
		{
			modulesSpawned = 0;
		}
	}
	[BepInPlugin("Swaggies.LevelScaling", "LevelScaling", "1.2.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public enum ExtractedUIDisplayType
		{
			AlwaysTotalMapValue,
			AlwaysCurrentMapValue,
			Alternate
		}

		public enum FoundUIDisplayType
		{
			AlwaysTotal,
			AlwaysCurrent,
			Alternate
		}

		public enum HaulGoalRoundingOptions
		{
			RoundToOne,
			RoundToTen,
			RoundToHundred,
			RoundToThousand
		}

		public enum CompatibilityMode
		{
			Client,
			Host,
			None
		}

		private const string _guid = "Swaggies.LevelScaling";

		private const string _name = "LevelScaling";

		public const string _ver = "1.2.2";

		private readonly Harmony harmony = new Harmony("Swaggies.LevelScaling");

		public static ManualLogSource loggy;

		public static bool LevelSimulationDisabled;

		public static bool Compatibility_SpawnConfig;

		public static ConfigEntry<bool> StatsUIShow_Base;

		public static ConfigEntry<bool> StatsUIShow_Map;

		public static ConfigEntry<bool> StatsUIShow_EndOfLevel;

		public static ConfigEntry<bool> StatsUIShow_Shop;

		public static ConfigEntry<bool> StatsUI_Flash;

		public static ConfigEntry<ExtractedUIDisplayType> StatsUIShow_ExtractedUI;

		public static ConfigEntry<FoundUIDisplayType> StatsUIShow_FoundUI;

		public static ConfigEntry<bool> StatsUIDisplay_Challenge;

		public static ConfigEntry<bool> StatsUIDisplay_Malfunction;

		public static ConfigEntry<bool> StatsUIDisplay_Time;

		public static ConfigEntry<bool> StatsUIDisplay_Deaths;

		public static ConfigEntry<bool> StatsUIDisplay_OrbDrops;

		public static ConfigEntry<bool> StatsUIDisplay_Extracted;

		public static ConfigEntry<bool> StatsUIDisplay_Broken;

		public static ConfigEntry<bool> StatsUIDisplay_Found;

		public static ConfigEntry<bool> StatsUIDisplay_Explored;

		public static ConfigEntry<int> StatsUI_YOffset;

		public static ConfigEntry<CompatibilityMode> LSCompatibilityMode;

		public static ConfigEntry<bool> DetailedLoadingScreen;

		public static ConfigEntry<bool> ShowMenuButton_MainMenu;

		public static ConfigEntry<bool> ShowMenuButton_PauseScreen;

		public static ConfigEntry<bool> ShowMenuButton_LobbyMenu;

		public static ConfigEntry<bool> ShowVersionOnMainMenu;

		public static ConfigEntry<bool> DisableLevelSimulationMenu;

		public static ConfigEntry<bool> DeepLogging;

		public static ConfigEntry<bool> ChallengeGuarantee;

		public static ConfigEntry<bool> ChallengeDisableMoonPhase;

		public static ConfigEntry<float> ChallengeChanceMultiplier;

		public static ConfigEntry<bool> ChallengeDisableLevelRequirements;

		public static ConfigEntry<bool> ChallengeTutorials;

		public static ConfigEntry<int> ChallengeChanceMultiplier_LightsOut;

		public static ConfigEntry<int> ChallengeChanceMultiplier_HighQuota;

		public static ConfigEntry<int> ChallengeChanceMultiplier_LargeMap;

		public static ConfigEntry<int> ChallengeChanceMultiplier_FoggyLevel;

		public static ConfigEntry<int> ChallengeChanceMultiplier_IncreasedDamage;

		public static ConfigEntry<int> ChallengeChanceMultiplier_FragileValuables;

		public static ConfigEntry<int> ChallengeChanceMultiplier_OverOvercharge;

		public static ConfigEntry<int> ChallengeChanceMultiplier_NoMap;

		public static ConfigEntry<int> ChallengeChanceMultiplier_EnemyRush;

		public static ConfigEntry<int> ChallengeChanceMultiplier_HiddenInformation;

		public static ConfigEntry<int> ChallengeChanceMultiplier_DangerZone;

		public static ConfigEntry<int> ChallengeChanceMultiplier_SharedDurability;

		public static ConfigEntry<int> ChallengeStartingLevel_LightsOut;

		public static ConfigEntry<int> ChallengeStartingLevel_HighQuota;

		public static ConfigEntry<int> ChallengeStartingLevel_LargeMap;

		public static ConfigEntry<int> ChallengeStartingLevel_FoggyLevel;

		public static ConfigEntry<int> ChallengeStartingLevel_IncreasedDamage;

		public static ConfigEntry<int> ChallengeStartingLevel_FragileValuables;

		public static ConfigEntry<int> ChallengeStartingLevel_OverOvercharge;

		public static ConfigEntry<int> ChallengeStartingLevel_NoMap;

		public static ConfigEntry<int> ChallengeStartingLevel_EnemyRush;

		public static ConfigEntry<int> ChallengeStartingLevel_HiddenInformation;

		public static ConfigEntry<int> ChallengeStartingLevel_DangerZone;

		public static ConfigEntry<int> ChallengeStartingLevel_SharedDurability;

		public static ConfigEntry<bool> Modify_ModuleCount;

		public static ConfigEntry<int> ModuleCountBase_Level1;

		public static ConfigEntry<int> ModuleCountBase_Level5;

		public static ConfigEntry<int> ModuleCountBase_Level10;

		public static ConfigEntry<int> ModuleCountBase_Level20;

		public static ConfigEntry<int> ModuleCountBase_Level50;

		public static ConfigEntry<int> ModuleCountBase_Level100;

		public static ConfigEntry<int> ModuleCount_RandomMin;

		public static ConfigEntry<int> ModuleCount_RandomMax;

		public static ConfigEntry<int> ModuleCount_PerPlayer;

		public static ConfigEntry<int> ModuleCount_PerPlayerMax;

		public static ConfigEntry<float> ModuleCountMultiplier_HeadmanManor;

		public static ConfigEntry<float> ModuleCountMultiplier_McJannekStation;

		public static ConfigEntry<float> ModuleCountMultiplier_SwiftbroomAcademy;

		public static ConfigEntry<float> ModuleCountMultiplier_MuseumOfHumanArt;

		public static ConfigEntry<Helpers.RoundingOptions> ModuleCount_Rounding;

		public static ConfigEntry<bool> Modify_ExtractionCount;

		public static ConfigEntry<int> ExtractionCountBase_Level1;

		public static ConfigEntry<int> ExtractionCountBase_Level5;

		public static ConfigEntry<int> ExtractionCountBase_Level10;

		public static ConfigEntry<int> ExtractionCountBase_Level20;

		public static ConfigEntry<int> ExtractionCountBase_Level50;

		public static ConfigEntry<int> ExtractionCountBase_Level100;

		public static ConfigEntry<int> ExtractionCount_RandomMin;

		public static ConfigEntry<int> ExtractionCount_RandomMax;

		public static ConfigEntry<int> ExtractionCount_PerPlayer;

		public static ConfigEntry<int> ExtractionCount_PerPlayerMax;

		public static ConfigEntry<Helpers.RoundingOptions> ExtractionCount_Rounding;

		public static ConfigEntry<bool> Modify_HaulGoal;

		public static ConfigEntry<float> HaulGoalBase_Level1;

		public static ConfigEntry<float> HaulGoalBase_Level5;

		public static ConfigEntry<float> HaulGoalBase_Level10;

		public static ConfigEntry<float> HaulGoalBase_Level20;

		public static ConfigEntry<float> HaulGoalBase_Level50;

		public static ConfigEntry<float> HaulGoalBase_Level100;

		public static ConfigEntry<float> HaulGoal_ExtractionModifier;

		public static ConfigEntry<HaulGoalRoundingOptions> HaulGoal_RoundingOptions;

		public static ConfigEntry<Helpers.RoundingOptions> HaulGoal_Rounding;

		public static ConfigEntry<bool> Modify_TotalMapValue;

		public static ConfigEntry<int> TotalMapValueBase_Level1;

		public static ConfigEntry<int> TotalMapValueBase_Level5;

		public static ConfigEntry<int> TotalMapValueBase_Level10;

		public static ConfigEntry<int> TotalMapValueBase_Level20;

		public static ConfigEntry<int> TotalMapValueBase_Level50;

		public static ConfigEntry<int> TotalMapValueBase_Level100;

		public static ConfigEntry<float> TotalMapValue_RandomMin;

		public static ConfigEntry<float> TotalMapValue_RandomMax;

		public static ConfigEntry<float> TotalMapValue_PerPlayer;

		public static ConfigEntry<int> TotalMapValue_PerPlayerMax;

		public static ConfigEntry<bool> Modify_EnemyTier1;

		public static ConfigEntry<int> EnemyTier1_Level1;

		public static ConfigEntry<int> EnemyTier1_Level5;

		public static ConfigEntry<int> EnemyTier1_Level10;

		public static ConfigEntry<int> EnemyTier1_Level20;

		public static ConfigEntry<int> EnemyTier1_Level50;

		public static ConfigEntry<int> EnemyTier1_Level100;

		public static ConfigEntry<Helpers.RoundingOptions> EnemyTier1_Rounding;

		public static ConfigEntry<bool> Modify_EnemyTier2;

		public static ConfigEntry<int> EnemyTier2_Level1;

		public static ConfigEntry<int> EnemyTier2_Level5;

		public static ConfigEntry<int> EnemyTier2_Level10;

		public static ConfigEntry<int> EnemyTier2_Level20;

		public static ConfigEntry<int> EnemyTier2_Level50;

		public static ConfigEntry<int> EnemyTier2_Level100;

		public static ConfigEntry<Helpers.RoundingOptions> EnemyTier2_Rounding;

		public static ConfigEntry<bool> Modify_EnemyTier3;

		public static ConfigEntry<int> EnemyTier3_Level1;

		public static ConfigEntry<int> EnemyTier3_Level5;

		public static ConfigEntry<int> EnemyTier3_Level10;

		public static ConfigEntry<int> EnemyTier3_Level20;

		public static ConfigEntry<int> EnemyTier3_Level50;

		public static ConfigEntry<int> EnemyTier3_Level100;

		public static ConfigEntry<Helpers.RoundingOptions> EnemyTier3_Rounding;

		public static ConfigEntry<bool> Modify_EnemyHealth;

		public static ConfigEntry<int> EnemyHealth_Level1;

		public static ConfigEntry<int> EnemyHealth_Level5;

		public static ConfigEntry<int> EnemyHealth_Level10;

		public static ConfigEntry<int> EnemyHealth_Level20;

		public static ConfigEntry<int> EnemyHealth_Level50;

		public static ConfigEntry<int> EnemyHealth_Level100;

		public static ConfigEntry<int> EnemyHealth_PerPlayer;

		public static ConfigEntry<int> EnemyHealth_PerPlayerMax;

		public static ConfigEntry<Helpers.RoundingOptions> EnemyHealth_Rounding;

		public static bool DeepLog => DeepLogging.Value;

		private void Awake()
		{
			loggy = Logger.CreateLogSource("Swaggies.LevelScaling");
			CreateConfig();
			if (DisableLevelSimulationMenu.Value)
			{
				LevelSimulationDisabled = true;
				loggy.LogMessage((object)"Level Simulation menu disabled.");
			}
			foreach (string key in Chainloader.PluginInfos.Keys)
			{
				if (key == "Index154.SpawnConfig")
				{
					Compatibility_SpawnConfig = true;
				}
			}
			if (Compatibility_SpawnConfig)
			{
				loggy.LogWarning((object)"Warning! Some Challenges and Malfunctions will be disabled as SpawnConfig is installed.");
				ChallengeManager._blacklistedChallenges.Add(ChallengeManager.ChallengeType.EnemyRush);
			}
			harmony.PatchAll(Assembly.GetExecutingAssembly());
			loggy.LogMessage((object)"LevelScaling's up and runnin' on 1.2.2");
			GlobalStatsManager.LoadGlobalStats();
			MalfunctionManager.Setup();
		}

		private void CreateConfig()
		{
			CreateStatsUIConfig();
			CreateMiscConfig();
			CreateChallengeConfig();
			CreateModuleConfig();
			CreateExtractionConfig();
			CreateHaulGoalConfig();
			CreateTotalMapValueConfig();
			CreateEnemyAmountsConfig();
			CreateEnemyHealthMultiplierConfig();
		}

		private void CreateStatsUIConfig()
		{
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Expected O, but got Unknown
			StatsUIShow_Base = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Show always", false, "Whether the level stats are always displayed on screen (applies when changed)");
			StatsUIShow_Map = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Show when map is open", true, "Whether the level stats are displayed with the map open (if not, they will be hidden with the map open, overriding other settings) (applies when changed)");
			StatsUIShow_EndOfLevel = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Show at end of level", true, "Whether the level stats will be shown at the end of a level (overriden by Always Show and Show With Map) (applies when changed)");
			StatsUIShow_Shop = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Show in shop", false, "Whether the level stats are shown in the shop (overriden by all other settings) (applies when changed)");
			StatsUI_Flash = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Flash on value change", true, "Make stats pop out by flashing them if their value changes (applies when changed)");
			StatsUIShow_ExtractedUI = ((BaseUnityPlugin)this).Config.Bind<ExtractedUIDisplayType>("Level Stats UI", "Extracted Value Display Type", ExtractedUIDisplayType.Alternate, "If the \"extracted value\" stats displays the total map value, or current remaining map value (taking broken valuables into account). Set to Alternate for automatically swapping between them every few seconds in-game (applies when changed)");
			StatsUIShow_FoundUI = ((BaseUnityPlugin)this).Config.Bind<FoundUIDisplayType>("Level Stats UI", "Found Amount Display Type", FoundUIDisplayType.Alternate, "If the \"found valuables\" stat displays the total amount, or current remaining amount (subtracting broken valuables that have not been found yet). Set to Alternate for automatically swapping between them every few seconds in-game (applies when changed)");
			StatsUIDisplay_Malfunction = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Active Malfunction", true, "Whether to display the active malfunction on the UI (applies when changed)");
			StatsUIDisplay_Challenge = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Active Challenge", true, "Whether to display the active challenge on the UI (applies when changed)");
			StatsUIDisplay_Time = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Level Timer", true, "Whether to display the level stopwatch on the UI (applies when changed)");
			StatsUIDisplay_Deaths = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Shop Death Count", true, "Whether to display the number of shop deaths on the UI (applies when changed)");
			StatsUIDisplay_OrbDrops = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Orb Drops Count", true, "Whether to display the number of orbs dropped from killed enemies on the UI (applies when changed)");
			StatsUIDisplay_Extracted = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Value Extracted", true, "Whether to display the amount of value extracted on the UI (applies when changed)");
			StatsUIDisplay_Broken = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Value Broken", true, "Whether to display the amount of value broken on the UI (applies when changed)");
			StatsUIDisplay_Found = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Valuables Found", true, "Whether to display the number of valuables found on the UI (applies when changed)");
			StatsUIDisplay_Explored = ((BaseUnityPlugin)this).Config.Bind<bool>("Level Stats UI", "Display Modules Explored", true, "Whether to display the number of modules explored on the UI (applies when changed)");
			StatsUI_YOffset = ((BaseUnityPlugin)this).Config.Bind<int>("Level Stats UI", "Y Offset", 80, new ConfigDescription("Change where to display the stats UI vertically (applies when stats ui is loaded)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-150, 150), Array.Empty<object>()));
		}

		private void CreateMiscConfig()
		{
			LSCompatibilityMode = ((BaseUnityPlugin)this).Config.Bind<CompatibilityMode>("Misc", "Compatibility Mode", CompatibilityMode.None, "NONE - All LevelScaling features are enabled.\nHOST - All networked features (such as Malfunctions and Challenges) are disabled, but patched host-only features (like adjusting map value or module counts) are still enabled.\nCLIENT - All features that are not client-sided are disabled.");
			DetailedLoadingScreen = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Detailed loading screen", false, "Whether to show what the game is actively doing whilst loading a new level. (applies when changed) (HOST ONLY)");
			ShowMenuButton_MainMenu = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Show Level Scaling button (Main Menu)", true, "Whether to show Level Scaling's menu button on the Main Menu. (applies when the main menu is loaded)");
			ShowMenuButton_LobbyMenu = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Show Level Scaling button (Lobby Menu)", true, "Whether to show Level Scaling's menu button on the multiplayer Lobby Menu. (applies when the game initially starts up)");
			ShowMenuButton_PauseScreen = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Show Level Scaling button (Pause Menu)", true, "Whether to show Level Scaling's menu button on the pause screen in-game. (applies when the game initially starts up)");
			ShowVersionOnMainMenu = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Show Mod Version on Main Menu", true, "Whether to show Level Scaling's current version next to REPO's version in the main menu. (applies when the main menu is loaded)");
			DisableLevelSimulationMenu = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Disable Level Simulation Menu", false, "Whether to disable the Level Simulation button (in case you want to prevent spoilers or something). (applies when the game initially starts up)");
			DeepLogging = ((BaseUnityPlugin)this).Config.Bind<bool>("Misc", "Deep logging", false, "When enabled, Level Scaling will log a lot of information relating to the changes and patches that the mod makes. This will FLOOD your log file and likely lag your game a bit, but may help with debugging stuff. Keep this off if you're just using Level Scaling normally. (applies when changed)");
		}

		private void CreateChallengeConfig()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Expected O, but got Unknown
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Expected O, but got Unknown
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected O, but got Unknown
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Expected O, but got Unknown
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Expected O, but got Unknown
			//IL_0376: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Expected O, but got Unknown
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Expected O, but got Unknown
			//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e6: Expected O, but got Unknown
			//IL_040e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Expected O, but got Unknown
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Expected O, but got Unknown
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_047e: Expected O, but got Unknown
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b0: Expected O, but got Unknown
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e3: Expected O, but got Unknown
			//IL_050c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0516: Expected O, but got Unknown
			//IL_053e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Expected O, but got Unknown
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Expected O, but got Unknown
			ChallengeChanceMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Challenge Levels", "Chance multiplier", 1f, new ConfigDescription("Adjust the multiplier for the chance of a challenge level appearing. Set to 0 to disable challenges completely. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 3f), Array.Empty<object>()));
			ChallengeGuarantee = ((BaseUnityPlugin)this).Config.Bind<bool>("Challenge Levels", "Guaranteed challenge levels", false, "Guarantees that every level will be a challenge level. Make sure Chance Multiplier is ABOVE 0. (applies before the start of each level) (HOST ONLY)");
			ChallengeDisableMoonPhase = ((BaseUnityPlugin)this).Config.Bind<bool>("Challenge Levels", "Prevent on new moon phases", true, "When enabled, challenge levels cannot appear on levels when the moon phase switches. (applies before the start of each level) (HOST ONLY)");
			ChallengeDisableLevelRequirements = ((BaseUnityPlugin)this).Config.Bind<bool>("Challenge Levels", "Disable level requirements", false, "When enabled, any challenge level can appear on any level number. (applies before the start of each level) (HOST ONLY)");
			ChallengeTutorials = ((BaseUnityPlugin)this).Config.Bind<bool>("Challenge Levels", "Show tutorials", true, "When a challenge appears, info about it will be shown at the start of the level. (applies when changed)");
			ChallengeChanceMultiplier_LightsOut = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Lights Out Weight", 30, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_HighQuota = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Overtime Weight", 50, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_LargeMap = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Enlarged Level Weight", 20, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_FoggyLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Dense Fog Weight", 20, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_IncreasedDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Increased Damage Weight", 30, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_FragileValuables = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Fragile Valuables Weight", 50, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_OverOvercharge = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Over-Overcharge Weight", 50, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_NoMap = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Broken Map Weight", 40, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_EnemyRush = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Enemy Rush Weight", 35, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_HiddenInformation = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Hidden Information Weight", 15, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_DangerZone = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Danger Zone Weight", 20, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeChanceMultiplier_SharedDurability = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Shared Durability Weight", 15, new ConfigDescription("Adjust the chance for this challenge to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			ChallengeStartingLevel_LightsOut = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Lights Out Starting Level", 3, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_HighQuota = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Overtime Starting Level", 7, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_LargeMap = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Enlarged Level Starting Level", 12, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_FoggyLevel = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Dense Fog Starting Level", 15, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_IncreasedDamage = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Increased Damage Starting Level", 5, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_FragileValuables = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Fragile Valuables Starting Level", 15, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_OverOvercharge = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Over-Overcharge Starting Level", 10, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_NoMap = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Broken Map Starting Level", 7, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_EnemyRush = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Enemy Rush Starting Level", 10, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_HiddenInformation = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Hidden Information Starting Level", 10, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_DangerZone = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Danger Zone Starting Level", 5, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
			ChallengeStartingLevel_SharedDurability = ((BaseUnityPlugin)this).Config.Bind<int>("Challenge Levels", "Shared Durability Starting Level", 12, new ConfigDescription("Adjust which level this challenge can begin to appear. (applies before the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
		}

		private void CreateModuleConfig()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Expected O, but got Unknown
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Expected O, but got Unknown
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Expected O, but got Unknown
			Modify_ModuleCount = ((BaseUnityPlugin)this).Config.Bind<bool>("Modules", "Modify Module Count", true, "Whether Level Scaling should apply its progressive module counts for levels. If disabled, vanilla behaviour will take over, and all of the following config options will be ignored. (applies at the start of each level) (HOST ONLY)");
			ModuleCountBase_Level1 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 1", 4, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCountBase_Level5 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 5", 6, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCountBase_Level10 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 10", 8, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCountBase_Level20 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 20", 15, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCountBase_Level50 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 50", 20, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCountBase_Level100 = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Module Count - Level 100", 25, new ConfigDescription("Number of modules at this level. Modules between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(3, 32), Array.Empty<object>()));
			ModuleCount_RandomMin = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Random Min", 0, new ConfigDescription("Minimum number of modules to randomly add to the base amount on each level. Negative numbers can make the map smaller. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-10, 10), Array.Empty<object>()));
			ModuleCount_RandomMax = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Random Max", 0, new ConfigDescription("Maximum number of modules to randomly add to the base amount on each level. Negative numbers can make the map smaller. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-10, 10), Array.Empty<object>()));
			ModuleCount_PerPlayer = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Modules Added Per Player", 0, new ConfigDescription("Number of added modules per player in the lobby. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-3, 3), Array.Empty<object>()));
			ModuleCount_PerPlayerMax = ((BaseUnityPlugin)this).Config.Bind<int>("Modules", "Accounted Players", 6, new ConfigDescription("Maximum number of players to account for when adding modules per player. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 9), Array.Empty<object>()));
			ModuleCountMultiplier_HeadmanManor = ((BaseUnityPlugin)this).Config.Bind<float>("Modules", "Multiplier - Headman Manor", 1f, new ConfigDescription("Module count multiplier for this specific level type. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			ModuleCountMultiplier_McJannekStation = ((BaseUnityPlugin)this).Config.Bind<float>("Modules", "Multiplier - McJannek Station", 1f, new ConfigDescription("Module count multiplier for this specific level type. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			ModuleCountMultiplier_SwiftbroomAcademy = ((BaseUnityPlugin)this).Config.Bind<float>("Modules", "Multiplier - Swiftbroom Academy", 1f, new ConfigDescription("Module count multiplier for this specific level type. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			ModuleCountMultiplier_MuseumOfHumanArt = ((BaseUnityPlugin)this).Config.Bind<float>("Modules", "Multiplier - Museum Of Human Art", 1f, new ConfigDescription("Module count multiplier for this specific level type. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			ModuleCount_Rounding = ((BaseUnityPlugin)this).Config.Bind<Helpers.RoundingOptions>("Modules", "Interpolation Rounding", Helpers.RoundingOptions.Floor, "How to round the module count when interpolating between level numbers. Floor will always round down, Ceil will always round up.");
		}

		private void CreateExtractionConfig()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Expected O, but got Unknown
			Modify_ExtractionCount = ((BaseUnityPlugin)this).Config.Bind<bool>("Extractions", "Modify Extraction Count", true, "Whether Level Scaling should apply its progressive extraction counts for levels. If disabled, vanilla behaviour will take over, and all of the following config options will be ignored. (applies at the start of each level) (HOST ONLY)");
			ExtractionCountBase_Level1 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 1", 1, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCountBase_Level5 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 5", 3, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCountBase_Level10 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 10", 4, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCountBase_Level20 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 20", 5, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCountBase_Level50 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 50", 7, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCountBase_Level100 = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Extraction Count - Level 100", 10, new ConfigDescription("Number of extractions at this level. Extractions between level configs will be interpolated and rounded down. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 12), Array.Empty<object>()));
			ExtractionCount_RandomMin = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Random Min", 0, new ConfigDescription("Minimum number of extractions to randomly add to the base amount on each level. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-5, 5), Array.Empty<object>()));
			ExtractionCount_RandomMax = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Random Max", 0, new ConfigDescription("Maximum number of extractions to randomly add to the base amount on each level. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-5, 5), Array.Empty<object>()));
			ExtractionCount_PerPlayer = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Added Per Player", 0, new ConfigDescription("Number of added extractions per player in the lobby. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(-3, 3), Array.Empty<object>()));
			ExtractionCount_PerPlayerMax = ((BaseUnityPlugin)this).Config.Bind<int>("Extractions", "Accounted Players", 3, new ConfigDescription("Maximum number of players to account for when adding extractions per player. (applies at the start of each level) (HOST ONLY)", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 5), Array.Empty<object>()));
			ExtractionCount_Rounding = ((BaseUnityPlugin)this).Config.Bind<Helpers.RoundingOptions>("Extractions", "Interpolation Rounding", Helpers.RoundingOptions.Floor, "How to round the extraction count when interpolating between level numbers. Floor will always round down, Ceil will always round up.");
		}

		private void CreateHaulGoalConfig()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Expected O, but got Unknown
			Modify_HaulGoal = ((BaseUnityPlugin)this).Config.Bind<bool>("Haul Goal", "Modify Haul Goal", true, "Whether Level Scaling should apply its progressive quotas for extraction points in levels. If disabled, vanilla behaviour will take over, and all of the following config options will be ignored. (a