using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
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 InfestationRework.Network;
using LethalConfig;
using LethalConfig.ConfigItems;
using LethalConfig.ConfigItems.Options;
using Microsoft.CodeAnalysis;
using OreoM.InfestationRework.NetcodePatcher;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("OreoM.InfestationRework")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0")]
[assembly: AssemblyProduct("InfestationRework")]
[assembly: AssemblyTitle("OreoM.InfestationRework")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace InfestationRework
{
	[BepInPlugin("OreoM.InfestationRework", "InfestationRework", "1.2.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class InfestationRework : BaseUnityPlugin
	{
		public const string LethalConfigGUID = "ainavt.lc.lethalconfig";

		public InfestationReworkConfig ConfigOptions;

		public static InfestationRework Instance { get; private set; }

		internal static ManualLogSource Logger { get; private set; }

		internal static Harmony? Harmony { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			NetcodePatch();
			Patch();
			Logger.LogInfo((object)"OreoM.InfestationRework v1.2.0 has loaded!");
		}

		private void NetcodePatch()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		internal static void Patch()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony = new Harmony("OreoM.InfestationRework");
			}
			Logger.LogDebug((object)"Patching...");
			Harmony.PatchAll();
			Logger.LogDebug((object)"Finished patching!");
		}

		internal static void Unpatch()
		{
			Logger.LogDebug((object)"Unpatching...");
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
			Logger.LogDebug((object)"Finished unpatching!");
		}
	}
	public class InfestationReworkConfig
	{
		public bool lethalConfigLoaded;

		public readonly ConfigEntry<SpawnMethod> spawnMethod;

		public readonly ConfigEntry<int> baseChance;

		public readonly ConfigEntry<int> normalFogChance;

		public readonly ConfigEntry<int> infestFogChance;

		public readonly ConfigEntry<int> targetChance;

		public readonly ConfigEntry<int> maxSpawn;

		public readonly Dictionary<EnemyType, ConfigEntry<bool>> selectableEnemies;

		public InfestationReworkConfig(ConfigFile cfg, EnemyType[] allEnemies)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: 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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			lethalConfigLoaded = Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig");
			cfg.SaveOnConfigSet = false;
			spawnMethod = cfg.Bind<SpawnMethod>("General", "Spawn Method", SpawnMethod.CUSTOM, "Choose between vanilla's and this mod's spawning algorithm");
			baseChance = cfg.Bind<int>("General", "Base Chance", 4, new ConfigDescription("% chance of an infestation any day", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			normalFogChance = cfg.Bind<int>("General", "Normal Fog Chance", 2, new ConfigDescription("% chance that a non-infestation day has indoor fog", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			infestFogChance = cfg.Bind<int>("General", "Infestation Fog Chance", 20, new ConfigDescription("% chance that an infestation day has indoor fog", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			targetChance = cfg.Bind<int>("General", "Target Chance", 60, new ConfigDescription("% chance of spawning the current infestation enemy when using the CUSTOM spawn method", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			maxSpawn = cfg.Bind<int>("General", "Overwrite Max Spawn", 0, new ConfigDescription("Overwrite the max spawn of the infestation target, leave at 0 to use the enemy's vanilla value", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 20), Array.Empty<object>()));
			selectableEnemies = new Dictionary<EnemyType, ConfigEntry<bool>>();
			foreach (EnemyType val in allEnemies)
			{
				if (val.isDaytimeEnemy || val.isOutsideEnemy)
				{
					continue;
				}
				if (selectableEnemies.ContainsKey(val))
				{
					InfestationRework.Logger.LogWarning((object)(val.enemyName + " has duplicate entries, skipping..."));
					continue;
				}
				HashSet<char> invalidChar = new HashSet<char> { '\n', '\t', ' ', '\\', '[', ']', '\'', '"' };
				ConfigEntry<bool> value = cfg.Bind<bool>("General.Targets", new string(val.enemyName.Where((char c) => !invalidChar.Contains(c)).ToArray()), val.enemyName == "Nutcracker" || val.enemyName == "HoarderBug", "Can choose " + val.enemyName + " for infestations");
				selectableEnemies[val] = value;
			}
			ClearOrphanedEntries(cfg);
			cfg.Save();
			cfg.SaveOnConfigSet = true;
			if (lethalConfigLoaded)
			{
				AddLethalConfigItems();
				ConfigLethalConfigModEntry();
			}
		}

		private void ClearOrphanedEntries(ConfigFile cfg)
		{
			PropertyInfo propertyInfo = AccessTools.Property(typeof(ConfigFile), "OrphanedEntries");
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)propertyInfo.GetValue(cfg);
			dictionary.Clear();
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void AddLethalConfigItems()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0088: 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_0094: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			EnumDropDownConfigItem<SpawnMethod> val = new EnumDropDownConfigItem<SpawnMethod>(spawnMethod, false);
			ConfigEntry<int> obj = baseChance;
			IntSliderOptions val2 = new IntSliderOptions();
			((BaseRangeOptions<int>)val2).Min = 0;
			((BaseRangeOptions<int>)val2).Max = 100;
			((BaseOptions)val2).RequiresRestart = false;
			IntSliderConfigItem val3 = new IntSliderConfigItem(obj, val2);
			ConfigEntry<int> obj2 = normalFogChance;
			IntSliderOptions val4 = new IntSliderOptions();
			((BaseRangeOptions<int>)val4).Min = 0;
			((BaseRangeOptions<int>)val4).Max = 100;
			((BaseOptions)val4).RequiresRestart = false;
			IntSliderConfigItem val5 = new IntSliderConfigItem(obj2, val4);
			ConfigEntry<int> obj3 = infestFogChance;
			IntSliderOptions val6 = new IntSliderOptions();
			((BaseRangeOptions<int>)val6).Min = 0;
			((BaseRangeOptions<int>)val6).Max = 100;
			((BaseOptions)val6).RequiresRestart = false;
			IntSliderConfigItem val7 = new IntSliderConfigItem(obj3, val6);
			ConfigEntry<int> obj4 = targetChance;
			IntSliderOptions val8 = new IntSliderOptions();
			((BaseRangeOptions<int>)val8).Min = 0;
			((BaseRangeOptions<int>)val8).Max = 100;
			((BaseOptions)val8).RequiresRestart = false;
			IntSliderConfigItem val9 = new IntSliderConfigItem(obj4, val8);
			ConfigEntry<int> obj5 = maxSpawn;
			IntSliderOptions val10 = new IntSliderOptions();
			((BaseRangeOptions<int>)val10).Min = 0;
			((BaseRangeOptions<int>)val10).Max = 20;
			((BaseOptions)val10).RequiresRestart = false;
			IntSliderConfigItem val11 = new IntSliderConfigItem(obj5, val10);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val3);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val5);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val7);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val9);
			LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val11);
			foreach (KeyValuePair<EnemyType, ConfigEntry<bool>> selectableEnemy in selectableEnemies)
			{
				BoolCheckBoxConfigItem val12 = new BoolCheckBoxConfigItem(selectableEnemy.Value, false);
				LethalConfigManager.AddConfigItem((BaseConfigItem)(object)val12);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		private void ConfigLethalConfigModEntry()
		{
			LethalConfigManager.SetModDescription("Infestation Rework configs");
		}
	}
	public enum SpawnMethod
	{
		VANILLA,
		CUSTOM
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "OreoM.InfestationRework";

		public const string PLUGIN_NAME = "InfestationRework";

		public const string PLUGIN_VERSION = "1.2.0";
	}
}
namespace InfestationRework.Patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void PostStart(GameNetworkManager __instance)
		{
			InfestationReworkNetwork.CreateAndRegisterPrefab();
			EnemyType[] allEnemies = Resources.FindObjectsOfTypeAll<EnemyType>();
			InfestationRework.Instance.ConfigOptions = new InfestationReworkConfig(((BaseUnityPlugin)InfestationRework.Instance).Config, allEnemies);
		}

		[HarmonyPatch("Disconnect")]
		[HarmonyPrefix]
		private static void PreDisconnect(GameNetworkManager __instance)
		{
			InfestationReworkNetwork.DespawnNetworkHandler();
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatches
	{
		[HarmonyPatch("OnDestroy")]
		[HarmonyPrefix]
		private static void PreOnDestroy(RoundManager __instance)
		{
			if (__instance.enemyRushIndex > -1 && RoundManagerHelper.saveMaxEnemyCount != 0)
			{
				StartOfRound.Instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount = RoundManagerHelper.saveMaxEnemyCount;
				RoundManagerHelper.saveMaxEnemyCount = 0;
			}
		}

		[HarmonyPatch("DespawnPropsAtEndOfRound")]
		[HarmonyPrefix]
		private static void PreDespawnPropsAtEndOfRound(RoundManager __instance)
		{
			if (__instance.enemyRushIndex > -1 && RoundManagerHelper.saveMaxEnemyCount != 0)
			{
				StartOfRound.Instance.currentLevel.Enemies[__instance.enemyRushIndex].enemyType.MaxCount = RoundManagerHelper.saveMaxEnemyCount;
				RoundManagerHelper.saveMaxEnemyCount = 0;
			}
		}

		[HarmonyPatch("RefreshEnemiesList")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TranspileRefreshEnemyList(IEnumerable<CodeInstruction> codes)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			CodeInstruction[] array = (CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RoundManagerHelper), "OverwriteRushCode", (Type[])null, (Type[])null))
			};
			return new CodeMatcher(codes, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloca_S, (object)null, (string)null)
			}).RemoveInstructions(152).Insert(array)
				.InstructionEnumeration();
		}

		[HarmonyPatch("AssignRandomEnemyToVent")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TranspileAssignRandomEnemyToVent(IEnumerable<CodeInstruction> codes)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			CodeInstruction[] array = (CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldloc_1, (object)null),
				new CodeInstruction(OpCodes.Ldloc_3, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RoundManagerHelper), "SpawnProbabilityCode", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stloc_S, (object)(sbyte)4)
			};
			CodeInstruction[] array2 = (CodeInstruction[])(object)new CodeInstruction[6]
			{
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(RoundManager), "SpawnProbabilities")),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(List<int>), "ToArray", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(RoundManager), "EnemySpawnRandom")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(RoundManagerHelper), "GetModifiedRandomWeightedIndex", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stloc_2, (object)null)
			};
			return new CodeMatcher(codes, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(RoundManager), "enemyRushIndex"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_M1, (object)null, (string)null)
			}).RemoveInstructions(83).InsertAndAdvance(array)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null)
				})
				.Advance(2)
				.RemoveInstructions(6)
				.Insert(array2)
				.InstructionEnumeration();
		}
	}
	internal static class RoundManagerHelper
	{
		public static int saveMaxEnemyCount;

		public static void OverwriteRushCode(RoundManager instance)
		{
			Random random = new Random(StartOfRound.Instance.randomMapSeed + 2145);
			int value = InfestationRework.Instance.ConfigOptions.baseChance.Value;
			int value2 = InfestationRework.Instance.ConfigOptions.normalFogChance.Value;
			int value3 = InfestationRework.Instance.ConfigOptions.infestFogChance.Value;
			if (random.Next(0, 100) < value)
			{
				if (((NetworkBehaviour)instance).IsServer || ((NetworkBehaviour)instance).IsHost)
				{
					InfestationReworkNetwork.Instance.shouldEnableIndoorFog.Value = random.Next(0, 100) < value3;
				}
				int num = -1;
				List<int> list = new List<int>();
				for (int i = 0; i < instance.currentLevel.Enemies.Count; i++)
				{
					if (InfestationRework.Instance.ConfigOptions.selectableEnemies.TryGetValue(instance.currentLevel.Enemies[i].enemyType, out ConfigEntry<bool> value4) && value4.Value)
					{
						list.Add(i);
					}
				}
				if (list.Count == 0)
				{
					((Component)instance.indoorFog).gameObject.SetActive(random.Next(0, 100) < value2);
					return;
				}
				num = (instance.enemyRushIndex = list[random.Next(0, list.Count)]);
				int value5 = InfestationRework.Instance.ConfigOptions.maxSpawn.Value;
				if (value5 != 0)
				{
					saveMaxEnemyCount = instance.currentLevel.Enemies[num].enemyType.MaxCount;
					instance.currentLevel.Enemies[num].enemyType.MaxCount = value5;
				}
			}
			else if (((NetworkBehaviour)instance).IsServer || ((NetworkBehaviour)instance).IsHost)
			{
				InfestationReworkNetwork.Instance.shouldEnableIndoorFog.Value = random.Next(0, 100) < value2;
			}
		}

		public static int SpawnProbabilityCode(RoundManager instance, EnemyType enemy, int index)
		{
			if (InfestationRework.Instance.ConfigOptions.spawnMethod.Value == SpawnMethod.VANILLA && instance.enemyRushIndex != -1)
			{
				if (instance.enemyRushIndex == index)
				{
					return 100;
				}
				return 1;
			}
			int num = 0;
			if (instance.increasedInsideEnemySpawnRateIndex == index)
			{
				return 100;
			}
			if (!enemy.useNumberSpawnedFalloff)
			{
				return (int)((double)instance.currentLevel.Enemies[index].rarity * (double)enemy.probabilityCurve.Evaluate(instance.timeScript.normalizedTimeOfDay));
			}
			return (int)((double)instance.currentLevel.Enemies[index].rarity * (double)enemy.probabilityCurve.Evaluate(instance.timeScript.normalizedTimeOfDay) * (double)enemy.numberSpawnedFalloff.Evaluate((float)enemy.numberSpawned / 10f));
		}

		public static int GetModifiedRandomWeightedIndex(RoundManager instance, int[] SpawnProbabilities, Random EnemySpawnRandom)
		{
			SpawnMethod value = InfestationRework.Instance.ConfigOptions.spawnMethod.Value;
			int value2 = InfestationRework.Instance.ConfigOptions.targetChance.Value;
			if (instance.enemyRushIndex != -1 && EnemySpawnRandom.Next(0, 100) < value2 && value == SpawnMethod.CUSTOM && !instance.EnemyCannotBeSpawned(instance.enemyRushIndex))
			{
				return instance.enemyRushIndex;
			}
			return instance.GetRandomWeightedIndex(SpawnProbabilities, EnemySpawnRandom);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static void PreAwake(StartOfRound __instance)
		{
			InfestationReworkNetwork.SpawnNetworkHandler();
		}
	}
}
namespace InfestationRework.Network
{
	internal class InfestationReworkNetwork : NetworkBehaviour
	{
		private static GameObject prefab;

		public NetworkVariable<bool> shouldEnableIndoorFog = new NetworkVariable<bool>(false, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public static InfestationReworkNetwork Instance { get; private set; }

		public static void CreateAndRegisterPrefab()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab != (Object)null))
			{
				prefab = new GameObject("OreoM.InfestationRework Prefab");
				GameObject obj = prefab;
				((Object)obj).hideFlags = (HideFlags)(((Object)obj).hideFlags | 0x3D);
				NetworkObject val = prefab.AddComponent<NetworkObject>();
				val.GlobalObjectIdHash = XXHash.Hash32(((Object)prefab).name);
				prefab.AddComponent<InfestationReworkNetwork>();
				NetworkManager.Singleton.AddNetworkPrefab(prefab);
				InfestationRework.Logger.LogInfo((object)"Network prefab created and registered");
			}
		}

		public static void SpawnNetworkHandler()
		{
			if (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost)
			{
				Object.Instantiate<GameObject>(prefab).GetComponent<NetworkObject>().Spawn(false);
				InfestationRework.Logger.LogInfo((object)"Network handler spawned");
			}
		}

		public static void DespawnNetworkHandler()
		{
			if ((Object)(object)Instance != (Object)null && ((Component)Instance).gameObject.GetComponent<NetworkObject>().IsSpawned && (NetworkManager.Singleton.IsServer || NetworkManager.Singleton.IsHost))
			{
				((Component)Instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
				InfestationRework.Logger.LogInfo((object)"Network handler despawned");
			}
		}

		private void Awake()
		{
			Instance = this;
		}

		public override void OnNetworkSpawn()
		{
			NetworkVariable<bool> obj = shouldEnableIndoorFog;
			obj.OnValueChanged = (OnValueChangedDelegate<bool>)(object)Delegate.Combine((Delegate?)(object)obj.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<bool>(ChangeIndoorFogState));
		}

		private void ChangeIndoorFogState(bool pValue, bool nValue)
		{
			((Component)RoundManager.Instance.indoorFog).gameObject.SetActive(nValue);
		}

		protected override void __initializeVariables()
		{
			if (shouldEnableIndoorFog == null)
			{
				throw new Exception("InfestationReworkNetwork.shouldEnableIndoorFog cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)shouldEnableIndoorFog).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)shouldEnableIndoorFog, "shouldEnableIndoorFog");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)shouldEnableIndoorFog);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "InfestationReworkNetwork";
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
		}
	}
}
namespace OreoM.InfestationRework.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}