using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using RemoveTheAnnoying.Patches;
using UnityEngine;
using UnityEngine.Rendering.HighDefinition;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RemoveTheAnnoying")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RemoveTheAnnoying")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("5445ad29-c98f-47fc-82e3-f3aeb564b4a7")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RemoveTheAnnoying
{
	[BepInPlugin("Kyoshi.RemoveAnnoyingStuff", "Remove Annoying Mechanics", "1.4.2")]
	public class RemoveAnnoyingBase : BaseUnityPlugin
	{
		private const string modGUID = "Kyoshi.RemoveAnnoyingStuff";

		private const string modName = "Remove Annoying Mechanics";

		private const string modVersion = "1.4.2";

		private readonly Harmony harmony = new Harmony("Kyoshi.RemoveAnnoyingStuff");

		public static RemoveAnnoyingBase Instance;

		public static ManualLogSource mls;

		public ConfigEntry<bool> MineshaftDisabled { get; private set; }

		public ConfigEntry<bool> BarberDisabled { get; private set; }

		public ConfigEntry<bool> ManeaterDisabled { get; private set; }

		public ConfigEntry<bool> AllowFactoryArtifice { get; private set; }

		public ConfigEntry<bool> CruiserFix { get; private set; }

		public ConfigEntry<bool> IncreasedArtificeScrap { get; private set; }

		public ConfigEntry<bool> AttemptForceManor { get; private set; }

		public ConfigEntry<bool> RemoveInteriorFog { get; private set; }

		public ConfigEntry<string> ForceWeather { get; private set; }

		public ConfigEntry<float> EclipsedMultiplier { get; private set; }

		public ConfigEntry<bool> IncreasedStartingCredits { get; private set; }

		public ConfigEntry<string> DisableWeather { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			mls = Logger.CreateLogSource("Kyoshi.RemoveAnnoyingStuff");
			mls.LogInfo((object)"Patching some QoL files!");
			BindConfig();
			ParseWeather(ForceWeather, DisableWeather);
			Patch(typeof(CruiserSeatTeleportPatch), typeof(CruiserFailsafePatch), typeof(ChooseNewRandomMapSeedPatch), typeof(DisableBadEnemySpawningPatch), typeof(RemoveFogPatch), typeof(ArtificeScrapPatch), typeof(WeatherPatch), typeof(StartingCreditsPatch), typeof(EclipsedScrapValuePatch));
			mls.LogInfo((object)"The game is now more playable!");
			ConfigStatus();
		}

		private void BindConfig()
		{
			CruiserFix = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "CruiserTeleportFix", true, "Allows players in a cruiser connected to the ship's magnet to be counted as in the ship when the ship takes off.");
			MineshaftDisabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Interior Generation", "DisableMineshaft", true, "Disables mineshaft interior when enabled.");
			AllowFactoryArtifice = ((BaseUnityPlugin)this).Config.Bind<bool>("Interior Generation", "AllowArtificeFactory", true, "Allows factory interior on Artifice when enabled.");
			AttemptForceManor = ((BaseUnityPlugin)this).Config.Bind<bool>("Interior Generation", "AttemptForceManor", false, "Attempts to force manor generation on all moons, when possible. Overrides all other interior config settings.");
			RemoveInteriorFog = ((BaseUnityPlugin)this).Config.Bind<bool>("Interior Generation", "RemoveInteriorFog", true, "Prevents the generation of interior fog introduced in v67.");
			BarberDisabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemies", "DisableBarber", true, "Disables all barber spawning when enabled.");
			ManeaterDisabled = ((BaseUnityPlugin)this).Config.Bind<bool>("Enemies", "DisableManeater", true, "Disables all maneater spawning when enabled.");
			IncreasedArtificeScrap = ((BaseUnityPlugin)this).Config.Bind<bool>("High Quota", "IncreasedArtificeScrap", false, "Sets the minimum scrap of Artifice to 31 and the maximum to 37. These are the values from v56.");
			ForceWeather = ((BaseUnityPlugin)this).Config.Bind<string>("Training", "ForceWeather", "disabled", "Forces all moon's weathers to be the specified type, defaulting to 'disabled' if input is invalid. Case-insensitive choices are: None, Rainy, Stormy, Foggy, Flooded, Eclipsed, and disabled");
			DisableWeather = ((BaseUnityPlugin)this).Config.Bind<string>("Training", "DisableWeather", "disabled", "Disables the specified weather from occuring on all moons. Is disabled by default or if input cannot be parsed. Will be disabled if ForceWeather has a vlaue that is not 'disabled'. Case-insensitive choices are: None, Rainy, Stormy, Foggy, Flooded, Eclipsed, and disabled.");
			IncreasedStartingCredits = ((BaseUnityPlugin)this).Config.Bind<bool>("Relaxed", "IncreasedStartingCredits", false, "Increases the starting credits enough to buy cruiser, 5 pro flashlights, 5 walkies, 2 shovels, 2 weed killer, and to go to Artifice (assuming no sales).");
			EclipsedMultiplier = ((BaseUnityPlugin)this).Config.Bind<float>("Relaxed", "EclipsedMultiplier", 1f, "Alters the global scrap value multiplier for eclipsed moons. The valid input range is (0-2]. A little goes a long way...");
		}

		private void ConfigStatus()
		{
			mls.LogDebug((object)$"Config CruiserTeleportFix = {CruiserFix.Value}");
			mls.LogDebug((object)$"Config DisableMineshaft = {MineshaftDisabled.Value}");
			mls.LogDebug((object)$"Config AllowArtificeFactory = {AllowFactoryArtifice.Value}");
			mls.LogDebug((object)$"Config AttemptForceManor = {AttemptForceManor.Value}");
			mls.LogDebug((object)$"Config RemoveInteriorFog = {RemoveInteriorFog.Value}");
			mls.LogDebug((object)$"Config DisableBarber = {BarberDisabled.Value}");
			mls.LogDebug((object)$"Config DisableManeater = {ManeaterDisabled.Value}");
			mls.LogDebug((object)$"Config IncreasedArtificeScrap = {IncreasedArtificeScrap.Value}");
			mls.LogDebug((object)("Config ForceWeather = " + ForceWeather.Value));
			mls.LogDebug((object)("Config DisableWeather = " + DisableWeather.Value));
			mls.LogDebug((object)$"Config IncreasedStartingCredits = {IncreasedStartingCredits.Value}");
			mls.LogDebug((object)$"Config EclipsedMultiplier = {EclipsedMultiplier.Value}");
		}

		private void Patch(params Type[] patchNames)
		{
			harmony.PatchAll(typeof(RemoveAnnoyingBase));
			foreach (Type type in patchNames)
			{
				harmony.PatchAll(type);
			}
		}

		private void ParseWeather(params ConfigEntry<string>[] entries)
		{
			foreach (ConfigEntry<string> val in entries)
			{
				string text = val.Value.ToLower();
				switch (text)
				{
				case "disabled":
				case "none":
				case "rainy":
				case "stormy":
				case "foggy":
				case "flooded":
				case "eclipsed":
					val.Value = text;
					break;
				default:
					mls.LogDebug((object)"Could not parse forced weather.");
					val.Value = "disabled";
					break;
				}
			}
		}
	}
}
namespace RemoveTheAnnoying.Patches
{
	[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
	public class ArtificeScrapPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly bool IncreasedArtificeScrapEnabled = RemoveAnnoyingBase.Instance.IncreasedArtificeScrap.Value;

		public static int v56ArtMin = 31;

		public static int v56ArtMax = 37;

		private static void Prefix(SelectableLevel ___currentLevel)
		{
			if (!IncreasedArtificeScrapEnabled)
			{
				Logger.LogInfo((object)"Artifice scrap increase diabled, I won't proceed.");
				return;
			}
			string text = ((Object)___currentLevel).name.Replace("Level", "");
			if (text.Equals("Artifice"))
			{
				Logger.LogDebug((object)"Attempting to alter scrap spawnrates...");
				___currentLevel.minScrap = v56ArtMin;
				___currentLevel.maxScrap = v56ArtMax;
				Logger.LogInfo((object)$"I successfully updated Artifice's scrap to a range of ({v56ArtMin},{v56ArtMax})");
			}
			else
			{
				Logger.LogInfo((object)"Current moon is not Artifice.");
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
	public class CruiserSeatTeleportPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly bool CruiserFixEnabled = RemoveAnnoyingBase.Instance.CruiserFix.Value;

		private static readonly float TeleportDelay = 4.642f;

		private static async void Postfix(StartOfRound __instance)
		{
			if (IsShipLeaving(__instance))
			{
				if (!CruiserFixEnabled)
				{
					Logger.LogInfo((object)"Cruiser fix diabled by user, I won't proceed.");
				}
				else
				{
					await ExecuteAfterDelay(TeleportDelay, __instance);
				}
			}
		}

		private static async Task ExecuteAfterDelay(float delay, StartOfRound __instance)
		{
			await Task.Delay((int)(delay * 1000f));
			TeleportSequence(__instance);
		}

		private static void TeleportSequence(StartOfRound __instance)
		{
			VehicleController attachedVehicle = __instance.attachedVehicle;
			if (IsMagnetProper(__instance, attachedVehicle))
			{
				PlayerControllerB currentDriver = attachedVehicle.currentDriver;
				TeleportPlayerToTerminal(currentDriver);
				PlayerControllerB currentPassenger = attachedVehicle.currentPassenger;
				TeleportPlayerToTerminal(currentPassenger);
				Logger.LogDebug((object)"Teleport sequence exited without any errors :)");
			}
		}

		private static bool IsShipLeaving(StartOfRound startOfRound)
		{
			return startOfRound.shipIsLeaving || startOfRound.shipLeftAutomatically;
		}

		private static bool IsMagnetProper(StartOfRound startOfRound, VehicleController vehicleController)
		{
			bool flag = startOfRound.magnetOn && (startOfRound.isObjectAttachedToMagnet || vehicleController.magnetedToShip);
			if (!flag)
			{
				Logger.LogInfo((object)"Teleport sequence exited due to cruiser not being connected to the ship's magnet.");
			}
			return flag;
		}

		private static bool TeleportPlayerToTerminal(PlayerControllerB player)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			Terminal val = Object.FindObjectOfType<Terminal>();
			player.TeleportPlayer(((Component)val).transform.position, false, 0f, false, true);
			Logger.LogInfo((object)("Successfully teleported " + player.playerUsername + " to Ship."));
			player.isInHangarShipRoom = true;
			return true;
		}
	}
	[HarmonyPatch(typeof(ElevatorAnimationEvents), "ElevatorFullyRunning")]
	public class CruiserFailsafePatch
	{
		private static readonly bool CruiserFixEnabled = RemoveAnnoyingBase.Instance.CruiserFix.Value;

		private static void Prefix()
		{
			if (!CruiserFixEnabled)
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			for (int i = 0; i < 100; i++)
			{
				if (!((Object)(object)localPlayerController.physicsParent == (Object)null))
				{
					VehicleController componentInParent = ((Component)localPlayerController.physicsParent).GetComponentInParent<VehicleController>();
					if (Object.op_Implicit((Object)(object)componentInParent) && componentInParent.magnetedToShip)
					{
						localPlayerController.isInElevator = true;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
	public class DisableBadEnemySpawningPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly HashSet<string> DisabledEnemies = new HashSet<string> { "ClaySurgeon", "CaveDweller" };

		private static readonly bool BarberDisabled = RemoveAnnoyingBase.Instance.BarberDisabled.Value;

		private static readonly bool ManeaterDisabled = RemoveAnnoyingBase.Instance.ManeaterDisabled.Value;

		private static void Prefix(SelectableLevel newLevel)
		{
			try
			{
				LevelOperation(newLevel, log: false);
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Prefix disabling ran incorrectly: {arg}");
			}
		}

		private static void Postfix(SelectableLevel newLevel)
		{
			try
			{
				LevelOperation(newLevel, log: true);
			}
			catch (Exception arg)
			{
				Logger.LogWarning((object)$"Postfix disabling ran incorrectly: {arg}");
			}
		}

		private static void LevelOperation(SelectableLevel newLevel, bool log)
		{
			if (SelectableLevelIsCompany(newLevel))
			{
				return;
			}
			if (!BarberDisabled && !ManeaterDisabled)
			{
				if (log)
				{
					Logger.LogInfo((object)"All unfun enemies allowed by user config.");
				}
				return;
			}
			if (!newLevel.Enemies.Any((SpawnableEnemyWithRarity e) => DisabledEnemies.Contains(((Object)e.enemyType).name)))
			{
				if (log)
				{
					Logger.LogInfo((object)"No unfun enemies detected in spawning pool.");
				}
				return;
			}
			int num = 0;
			foreach (SpawnableEnemyWithRarity enemy in newLevel.Enemies)
			{
				if (DisableEnemyIfStinky(enemy, log))
				{
					num++;
				}
			}
			if (log)
			{
				Logger.LogInfo((object)$"Disabled {num} unfun enemies in current level.");
			}
			if (log && num > 0)
			{
				Logger.LogDebug((object)"Level will not spawn any unfun enemies.");
			}
		}

		private static bool DisableEnemyIfStinky(SpawnableEnemyWithRarity enemy, bool log)
		{
			string name = ((Object)enemy.enemyType).name;
			if (DisabledEnemies.Contains(name))
			{
				if (name.Equals("ClaySurgeon") && !BarberDisabled)
				{
					if (log)
					{
						Logger.LogInfo((object)"Barber allowed due to user config.");
					}
					return false;
				}
				if (name.Equals("CaveDweller") && !ManeaterDisabled)
				{
					if (log)
					{
						Logger.LogInfo((object)"Maneater allowed due to user config");
					}
					return false;
				}
				enemy.rarity = 0;
				enemy.enemyType.spawningDisabled = true;
				if (log)
				{
					Logger.LogInfo((object)("Spawning of " + name + " disabled."));
				}
				return true;
			}
			return false;
		}

		private static bool SelectableLevelIsCompany(SelectableLevel selectableLevel)
		{
			string text = ((Object)selectableLevel).name.Replace("Level", "");
			return text.Equals("CompanyBuilding");
		}
	}
	[HarmonyPatch(typeof(RoundManager), "RefreshEnemiesList")]
	[HarmonyPriority(0)]
	public class RemoveFogPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly bool RemoveFogEnabled = RemoveAnnoyingBase.Instance.RemoveInteriorFog.Value;

		private static void Postfix()
		{
			if (!RemoveFogEnabled)
			{
				Logger.LogInfo((object)"Remove fog diabled by user, I won't proceed.");
			}
			else if (!((Object)(object)RoundManager.Instance == (Object)null) && !((Object)(object)RoundManager.Instance.indoorFog == (Object)null))
			{
				LocalVolumetricFog indoorFog = RoundManager.Instance.indoorFog;
				if (DisableFog(indoorFog))
				{
					Logger.LogInfo((object)"Fog successfully disabled in current level.");
				}
				else
				{
					Logger.LogInfo((object)"Fog was not detected in the current level or disabling was unsuccessful.");
				}
			}
		}

		private static bool DisableFog(LocalVolumetricFog localFog)
		{
			if ((Object)(object)localFog == (Object)null)
			{
				return false;
			}
			((Component)localFog).gameObject.SetActive(false);
			return true;
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "ChooseNewRandomMapSeed")]
	public class ChooseNewRandomMapSeedPatch
	{
		[HarmonyPatch(typeof(RoundManager), "GenerateNewFloor")]
		public class GenerateNewFloorPatch
		{
			private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

			private static readonly bool MineshaftDisabled = RemoveAnnoyingBase.Instance.MineshaftDisabled.Value;

			private static readonly bool AllowFactoryArtifice = RemoveAnnoyingBase.Instance.AllowFactoryArtifice.Value;

			private static bool Prefix(RoundManager __instance)
			{
				string text = ((Object)__instance.currentLevel).name.Replace("Level", "");
				try
				{
					if (MineshaftDisabled)
					{
						__instance.currentLevel.dungeonFlowTypes = __instance.currentLevel.dungeonFlowTypes.Where(IsNotMineshaft).ToArray();
						Logger.LogDebug((object)("Removed mineshaft generation of " + text + "."));
					}
					if (text.Equals("Artifice") && !AllowFactoryArtifice)
					{
						__instance.currentLevel.dungeonFlowTypes = __instance.currentLevel.dungeonFlowTypes.Where(IsNotFactory).ToArray();
						Logger.LogDebug((object)("Removed factory generation of " + text + "."));
					}
					return true;
				}
				catch (Exception ex)
				{
					Logger.LogWarning((object)("Error removing interior type: " + ex.Message));
					return false;
				}
			}

			private static bool IsNotMineshaft(IntWithRarity flow)
			{
				return flow.id != 4;
			}

			private static bool IsNotFactory(IntWithRarity flow)
			{
				return flow.id != 0;
			}
		}

		public enum InteriorType
		{
			Factory = 0,
			Manor = 1,
			Mineshaft = 4
		}

		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly bool MineshaftDisabled = RemoveAnnoyingBase.Instance.MineshaftDisabled.Value;

		private static readonly bool AllowFactoryArtifice = RemoveAnnoyingBase.Instance.AllowFactoryArtifice.Value;

		private static readonly bool ManorForced = RemoveAnnoyingBase.Instance.AttemptForceManor.Value;

		private const int MaxSeedAttempts = 1000;

		private const int MaxSeedValue = 100000000;

		private static readonly Dictionary<int?, string> interiorMap = new Dictionary<int?, string>();

		private static void Postfix(StartOfRound __instance)
		{
			if (!MineshaftDisabled && AllowFactoryArtifice)
			{
				Logger.LogInfo((object)"All interiors are enabled, so I won't regenerate the seed.");
				return;
			}
			Logger.LogDebug((object)$"Initialize Dictionary: {InitializeInteriorDict()}");
			int randomMapSeed = __instance.randomMapSeed;
			RoundManager instance = RoundManager.Instance;
			InteriorType? interiorType = DetermineType(randomMapSeed, instance);
			string text = ((Object)__instance.currentLevel).name.Replace("Level", "");
			if (!interiorType.HasValue)
			{
				return;
			}
			interiorType = interiorType.Value;
			Logger.LogInfo((object)$"Seed: {randomMapSeed} is a {interiorType}.");
			InteriorType?[][] removeables = GetRemoveables();
			bool flag = text.Equals("Artifice");
			if (ManorForced)
			{
				if (!RemoveInteriorGeneration(interiorType, removeables[5], instance, __instance))
				{
					Logger.LogDebug((object)"Forcing Manor was unsuccessful, defaulting to other interior config rules...");
					if (MineshaftDisabled)
					{
						RemoveInteriorGeneration(interiorType, removeables[0], instance, __instance);
					}
					else if (!AllowFactoryArtifice && flag)
					{
						RemoveInteriorGeneration(interiorType, removeables[2], instance, __instance);
					}
				}
			}
			else if (MineshaftDisabled)
			{
				if (AllowFactoryArtifice)
				{
					RemoveInteriorGeneration(interiorType, removeables[0], instance, __instance);
				}
				else if (!AllowFactoryArtifice && flag)
				{
					RemoveInteriorGeneration(interiorType, removeables[5], instance, __instance);
				}
				else
				{
					RemoveInteriorGeneration(interiorType, removeables[0], instance, __instance);
				}
			}
			else if (!MineshaftDisabled && !AllowFactoryArtifice && flag)
			{
				RemoveInteriorGeneration(interiorType, removeables[2], instance, __instance);
			}
		}

		private static bool RemoveInteriorGeneration(InteriorType? currentType, InteriorType?[] disallowedTypes, RoundManager manager, StartOfRound __instance)
		{
			if (disallowedTypes.Length == 0 || disallowedTypes.Length == 3)
			{
				return false;
			}
			if (disallowedTypes == null || disallowedTypes.Contains(null))
			{
				return false;
			}
			if (!disallowedTypes.Contains(currentType))
			{
				Logger.LogInfo((object)"No need to regenerate seed.");
				return false;
			}
			int?[] second = ((IEnumerable<InteriorType?>)disallowedTypes).Select((Func<InteriorType?, int?>)((InteriorType? dt) => (int)dt.Value)).ToArray();
			string[] array = disallowedTypes.Select((InteriorType? dt) => interiorMap[(int)dt.Value]).ToArray();
			IEnumerable<string> values = array.Zip(second, (string name, int? typeVal) => $"{name}: {typeVal}");
			Logger.LogDebug((object)string.Format("Current: {0}; Disallowed: {1}", currentType, string.Join(", ", values)));
			Logger.LogInfo((object)(string.Join(" or ", array) + " seed identified, trying to regenerate..."));
			manager.hasInitializedLevelRandomSeed = false;
			manager.InitializeRandomNumberGenerators();
			for (int i = 0; i < 1000; i++)
			{
				int num = NewSeed();
				InteriorType? interiorType = DetermineType(num, manager);
				Logger.LogDebug((object)$"Attempt {i + 1} - Seed: {num} Interior: {interiorType}");
				if (!interiorType.HasValue)
				{
					Logger.LogWarning((object)"Detected unknown interior.");
					return false;
				}
				if (!disallowedTypes.Contains(new InteriorType?(interiorType.Value).GetValueOrDefault()))
				{
					__instance.randomMapSeed = num;
					Logger.LogInfo((object)$"Generated new map seed: {num} after {i + 1} attempts.");
					return true;
				}
			}
			Logger.LogWarning((object)"Regeneration failed after 1000 attempts");
			return false;
		}

		private static InteriorType? DetermineType(int seed, RoundManager manager)
		{
			try
			{
				if (ManagerIsCompany(manager))
				{
					Logger.LogDebug((object)"The Company Building Detected.");
					return null;
				}
				if (manager.currentLevel.dungeonFlowTypes == null || manager.currentLevel.dungeonFlowTypes.Length == 0)
				{
					Logger.LogDebug((object)$"Seed {seed}: Moon is not recognized as having an interior.");
					return null;
				}
				Random random = new Random(seed);
				List<int> list = manager.currentLevel.dungeonFlowTypes.Select((IntWithRarity flow) => flow.rarity).ToList();
				Logger.LogDebug((object)("List: " + string.Join(", ", list)));
				int randomWeightedIndex = manager.GetRandomWeightedIndex(list.ToArray(), random);
				Logger.LogDebug((object)$"Weight: {randomWeightedIndex}");
				int id = manager.currentLevel.dungeonFlowTypes[randomWeightedIndex].id;
				if (Enum.IsDefined(typeof(InteriorType), id))
				{
					return (InteriorType)id;
				}
				return null;
			}
			catch (Exception ex)
			{
				Logger.LogWarning((object)$"Error determining interior type for seed {seed}: {ex.Message}");
				return null;
			}
		}

		private static int NewSeed()
		{
			return new Random().Next(1, 100000000);
		}

		private static bool ManagerIsCompany(RoundManager manager)
		{
			string text = ((Object)manager.currentLevel).name.Replace("Level", "");
			return text.Equals("CompanyBuilding");
		}

		private static bool InitializeInteriorDict()
		{
			if (interiorMap.ContainsKey(0))
			{
				return false;
			}
			interiorMap.Add(0, "Factory");
			interiorMap.Add(1, "Manor");
			interiorMap.Add(4, "Mineshaft");
			return true;
		}

		private static InteriorType?[][] GetRemoveables()
		{
			return new InteriorType?[6][]
			{
				new InteriorType?[1] { InteriorType.Mineshaft },
				new InteriorType?[1] { InteriorType.Manor },
				new InteriorType?[1] { InteriorType.Factory },
				new InteriorType?[2]
				{
					InteriorType.Mineshaft,
					InteriorType.Manor
				},
				new InteriorType?[2]
				{
					InteriorType.Factory,
					InteriorType.Manor
				},
				new InteriorType?[2]
				{
					InteriorType.Mineshaft,
					InteriorType.Factory
				}
			};
		}
	}
	[HarmonyPatch(typeof(TimeOfDay), "Awake")]
	public class StartingCreditsPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly bool IncreaseEnabled = RemoveAnnoyingBase.Instance.IncreasedStartingCredits.Value;

		private static readonly int IncreasedAmount = CalculateDesired();

		private static void Postfix(TimeOfDay __instance)
		{
			if (!IncreaseEnabled)
			{
				Logger.LogInfo((object)"Increased starting credits diabled by user, I won't proceed.");
				return;
			}
			__instance.quotaVariables.startingCredits = IncreasedAmount;
			Logger.LogInfo((object)$"I set the starting credits to {IncreasedAmount} successfully.");
		}

		private static int CalculateDesired()
		{
			int num = 400;
			int num2 = 1500;
			int num3 = 25;
			int num4 = 25;
			int num5 = 12;
			int num6 = 30;
			return num + num2 + 2 * num3 + 5 * num4 + 5 * num5 + 2 * num6;
		}
	}
	[HarmonyPatch(typeof(RoundManager), "SpawnScrapInLevel")]
	public class EclipsedScrapValuePatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly float Multiplier = RemoveAnnoyingBase.Instance.EclipsedMultiplier.Value;

		public static void Prefix(RoundManager __instance)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			if (Multiplier <= 0f || Multiplier > 2f || Multiplier == 1f)
			{
				Logger.LogInfo((object)$"Given multiplier was {Multiplier}, I won't proceed.");
				return;
			}
			if ((int)TimeOfDay.Instance.currentLevelWeather == 5)
			{
				typeof(RoundManager).GetField("scrapValueMultiplier").SetValue(__instance, Multiplier);
			}
			Logger.LogInfo((object)$"I set the spawned scrap multiplier to {Multiplier} successfully.");
		}
	}
	[HarmonyPatch(typeof(StartOfRound), "SetPlanetsWeather")]
	public class WeatherPatch
	{
		private static readonly ManualLogSource Logger = RemoveAnnoyingBase.mls;

		private static readonly string ForceWeather = RemoveAnnoyingBase.Instance.ForceWeather.Value;

		private static readonly string DisableWeather = RemoveAnnoyingBase.Instance.DisableWeather.Value;

		private static readonly Dictionary<string, LevelWeatherType[]> MoonWeathers = new Dictionary<string, LevelWeatherType[]>();

		private static readonly LevelWeatherType[] AllWeathers;

		private static readonly int MaximumRerollAttempts;

		private static bool Prefix(SelectableLevel[] ___levels)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			Logger.LogInfo((object)"Performing weather tweaks");
			if (ForceWeather != null && !ForceWeather.Equals("disabled"))
			{
				LevelWeatherType? val = ConvertConfigEntryToWeatherType(ForceWeather);
				if (val.HasValue)
				{
					return ForceAllPlanetsWeather(___levels, val.Value);
				}
				Logger.LogInfo((object)"ForceWeather input was not identified.");
				return true;
			}
			if (DisableWeather != null && !DisableWeather.Equals("disabled"))
			{
				LevelWeatherType? val2 = ConvertConfigEntryToWeatherType(DisableWeather);
				if (val2.HasValue)
				{
					return PreventWeatherGeneration(___levels, val2.Value);
				}
				Logger.LogInfo((object)"DisableWeather input was not identified.");
				return true;
			}
			return true;
		}

		private static LevelWeatherType? ConvertConfigEntryToWeatherType(string value)
		{
			return value.ToLower() switch
			{
				"none" => (LevelWeatherType)(-1), 
				"rainy" => (LevelWeatherType)1, 
				"stormy" => (LevelWeatherType)2, 
				"foggy" => (LevelWeatherType)3, 
				"flooded" => (LevelWeatherType)4, 
				"eclipsed" => (LevelWeatherType)5, 
				_ => null, 
			};
		}

		private static bool ForceAllPlanetsWeather(SelectableLevel[] levels, LevelWeatherType forcedType)
		{
			//IL_005c: 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)
			foreach (SelectableLevel val in levels)
			{
				Logger.LogInfo((object)("Setting " + ((Object)val).name.Replace("Level", "") + "'s weather to " + ForceWeather + "."));
				val.currentWeather = forcedType;
			}
			Logger.LogInfo((object)("All level's weather set to " + ForceWeather + "."));
			return false;
		}

		private static bool PreventWeatherGeneration(SelectableLevel[] levels, LevelWeatherType restrictedType)
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			MoonWeathersDictionary();
			foreach (SelectableLevel val in levels)
			{
				string text = ((Object)val).name.Replace("Level", "");
				if (text.Equals("CompanyBuilding"))
				{
					continue;
				}
				try
				{
					bool flag = false;
					HashSet<LevelWeatherType> hashSet = new HashSet<LevelWeatherType>(MoonWeathers[text]);
					for (int j = 0; j < MaximumRerollAttempts; j++)
					{
						if (val.currentWeather != restrictedType)
						{
							break;
						}
						val.currentWeather = hashSet.ElementAt(new Random().Next(hashSet.Count));
						Logger.LogDebug((object)$"Rerolled level {text} to type {val.currentWeather}.");
						flag = true;
					}
					if (flag)
					{
						Logger.LogInfo((object)$"Finished rerolling level {text}: Final type = {val.currentWeather}.");
					}
					else
					{
						Logger.LogInfo((object)("Level " + text + "'s weather was not restricted so no action was taken."));
					}
				}
				catch
				{
					Logger.LogDebug((object)$"Error altering weather of type {restrictedType} on {text}.");
				}
			}
			return false;
		}

		private static void MoonWeathersDictionary()
		{
			if (!MoonWeathers.ContainsKey("Artifice"))
			{
				MoonWeathers.Add("CompanyBuilding", (LevelWeatherType[])(object)new LevelWeatherType[1] { (LevelWeatherType)(-1) });
				MoonWeathers.Add("Experimentation", AllWeathers);
				MoonWeathers.Add("Assurance", AllWeathers);
				MoonWeathers.Add("Vow", ExcludeWeatherType((LevelWeatherType)1));
				MoonWeathers.Add("Offense", ExcludeWeatherType((LevelWeatherType)3));
				MoonWeathers.Add("March", ExcludeWeatherType((LevelWeatherType)1));
				MoonWeathers.Add("Adamance", AllWeathers);
				MoonWeathers.Add("Rend", (LevelWeatherType[])(object)new LevelWeatherType[2]
				{
					(LevelWeatherType)2,
					(LevelWeatherType)5
				});
				MoonWeathers.Add("Dine", ExcludeWeatherType((LevelWeatherType)2, (LevelWeatherType)3));
				MoonWeathers.Add("Titan", ExcludeWeatherType((LevelWeatherType)1, (LevelWeatherType)4));
				MoonWeathers.Add("Artifice", ExcludeWeatherType((LevelWeatherType)3));
				MoonWeathers.Add("Embrion", (LevelWeatherType[])(object)new LevelWeatherType[2]
				{
					(LevelWeatherType)3,
					(LevelWeatherType)5
				});
			}
		}

		private static LevelWeatherType[] ExcludeWeatherType(params LevelWeatherType[] excludes)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			HashSet<LevelWeatherType> hashSet = new HashSet<LevelWeatherType>(excludes);
			List<LevelWeatherType> list = new List<LevelWeatherType>();
			LevelWeatherType[] allWeathers = AllWeathers;
			foreach (LevelWeatherType item in allWeathers)
			{
				if (!hashSet.Contains(item))
				{
					list.Add(item);
				}
			}
			return list.ToArray();
		}

		static WeatherPatch()
		{
			LevelWeatherType[] array = new LevelWeatherType[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			AllWeathers = (LevelWeatherType[])(object)array;
			MaximumRerollAttempts = 100;
		}
	}
}