using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalEvents.Common;
using LethalEvents.Configuration;
using LethalEvents.Events;
using LethalEvents.Patches;
using Microsoft.CodeAnalysis;
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: AssemblyCompany("LethalEvents")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Lethal Events")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("LethalEvents")]
[assembly: AssemblyTitle("LethalEvents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace LethalEvents
{
	[BepInPlugin("LethalEvents", "LethalEvents", "1.0.0")]
	public class LethalEvents : BaseUnityPlugin
	{
		internal static LethalEvents Instance { get; set; }

		internal static PlayerControllerB PlayerRef { get; set; }

		private void Awake()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			LethalEventsState.Config = LethalConfig.BindConfigSettings();
			Harmony val = new Harmony("LethalEvents");
			LELogger.Mls = Logger.CreateLogSource("LethalEvents");
			val.PatchAll(typeof(LevelLethalEventPatch));
			val.PatchAll(typeof(AllowPlayerDeathPatch));
			val.PatchAll(typeof(InfiniteSprintPatch));
			val.PatchAll(typeof(NightVisionPatch));
			val.PatchAll(typeof(PlayerControllerBStartPatch));
			val.PatchAll(typeof(RoundManagerStartPatch));
			LELogger.Mls = ((BaseUnityPlugin)this).Logger;
			LogSplash();
		}

		private void LogSplash()
		{
			LELogger.Mls.LogMessage((object)"\r\n _          _   _           _   _____                _       \r\n| |        | | | |         | | |  ___|              | |      \r\n| |     ___| |_| |__   __ _| | | |____   _____ _ __ | |_ ___ \r\n| |    / _ \\ __| '_ \\ / _` | | |  __\\ \\ / / _ \\ '_ \\| __/ __|\r\n| |___|  __/ |_| | | | (_| | | | |___\\ V /  __/ | | | |_\\__ \\\r\n\\_____/\\___|\\__|_| |_|\\__,_|_| \\____/ \\_/ \\___|_| |_|\\__|___/\r\n                                                             \r\n");
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LethalEvents";

		public const string PLUGIN_NAME = "LethalEvents";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace LethalEvents.Patches
{
	[HarmonyPatch(typeof(PlayerControllerB), "AllowPlayerDeath")]
	internal class AllowPlayerDeathPatch : IPatchable
	{
		[HarmonyPrefix]
		private static bool OverrideDeath()
		{
			LELogger.Mls.LogMessage((object)"Override Death");
			if (!LethalEventsState.IsHost)
			{
				return true;
			}
			return !LethalEventsState.EnableGod;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Update")]
	internal class InfiniteSprintPatch : IPatchable
	{
		[HarmonyPostfix]
		private static void Infinitesprint(ref float ___sprintMeter)
		{
			if (LethalEventsState.EnableInfiniteSprint)
			{
				Math.Clamp(___sprintMeter += 0.02f, 0f, 1f);
			}
		}
	}
	internal interface IPatchable
	{
	}
	[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
	internal class LevelLethalEventPatch : IPatchable
	{
		[HarmonyPrefix]
		private static bool ModifyLevel(ref SelectableLevel newLevel)
		{
			LELogger.Mls.LogMessage((object)"Loaded new level. Initiating event sequence..");
			if (!((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				LELogger.Mls.LogWarning((object)"Client not host, no modification will be made.");
				return false;
			}
			LethalEventHandler.NormalizeLevel(newLevel);
			if (newLevel.sceneName == "CompanyBuilding")
			{
				LELogger.Mls.LogInfo((object)"Company building, no events happen here.");
				return false;
			}
			LethalEventHandler.HandleMoonHeat(newLevel);
			SelectableLevel obj = newLevel;
			obj.maxEnemyPowerCount += LethalEventsState.Config.MaxEnemyPowerIncrement.Value;
			LethalEvent randomLethalEvent = LethalEventHandler.GetRandomLethalEvent(newLevel);
			ILethalEvent lethalEventExecutor = LethalEventHandler.GetLethalEventExecutor(randomLethalEvent);
			LethalEventHandler.LogCurrentMoonHeat(newLevel);
			LethalEventHandler.LogLethalEventName(randomLethalEvent);
			lethalEventExecutor.Execute(newLevel);
			return true;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "SetNightVisionEnabled")]
	internal class NightVisionPatch : IPatchable
	{
		[HarmonyPostfix]
		private static void SetNightVisionEnabled()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (LethalEventsState.EnableNightVision)
			{
				LethalEvents.PlayerRef.nightVision.color = Color.green;
				LethalEvents.PlayerRef.nightVision.intensity = 1000f;
				LethalEvents.PlayerRef.nightVision.range = 10000f;
				((Behaviour)LethalEvents.PlayerRef.nightVision).enabled = true;
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "Start")]
	internal class PlayerControllerBStartPatch : IPatchable
	{
		[HarmonyPostfix]
		private static void Start(ref PlayerControllerB __instance)
		{
			LethalEvents.PlayerRef = __instance;
		}
	}
	[HarmonyPatch(typeof(RoundManager), "Start")]
	internal class RoundManagerStartPatch : IPatchable
	{
		[HarmonyPrefix]
		private static void setIsHost()
		{
			LELogger.Mls.LogMessage((object)"Start");
			LethalEventsState.IsHost = ((NetworkBehaviour)RoundManager.Instance).NetworkManager.IsHost;
		}
	}
}
namespace LethalEvents.Events
{
	internal class ArachnophobiaEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LethalEventHandler.SetEnemiesRarity<SandSpiderAI>(currentLevel);
		}
	}
	internal class BrackenAndCoilEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LethalEventHandler.SetEnemiesRarity<FlowermanAI>(currentLevel);
			LethalEventHandler.SetEnemiesRarity<SpringManAI>(currentLevel);
		}
	}
	internal class DeliveryEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			int num = Random.Range(LethalEventsState.Config.MinDeliveryItems.Value, LethalEventsState.Config.MaxDeliveryItems.Value);
			for (int i = 0; i < num; i++)
			{
				int item = Random.Range(0, 7);
				if (LethalEventsState.Config.ChanceForHighTierDeliveryItems.Value > Random.Range(0, 100))
				{
					item = Random.Range(7, 12);
				}
				val.orderedItemsFromTerminal.Add(item);
			}
		}
	}
	internal interface ILethalEvent
	{
		internal void Execute(SelectableLevel currentLevel);
	}
	internal enum LethalEvent
	{
		[Description("<color=green>None")]
		None,
		[Description("<color=red>Turret Hell")]
		TurretHell,
		[Description("<color=red>Mine Hell")]
		MineHell,
		[Description("<color=red>Arachnophobia")]
		Arachnophobia,
		[Description("<color=red>Look Up")]
		SnareFleas,
		[Description("<color=red>The Worst Combo")]
		BrackenAndCoilhead,
		[Description("<color=red>Slime City")]
		SlimeCity,
		[Description("<color=red>Lootbug Haven")]
		LootbugHaven,
		[Description("<color=green>Free delivery!")]
		Delivery
	}
	internal class LootbugHavenEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LethalEventHandler.SetEnemiesRarity<HoarderBugAI>(currentLevel);
		}
	}
	internal class TurretHellEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			SpawnableMapObject[] spawnableMapObjects = currentLevel.spawnableMapObjects;
			foreach (SpawnableMapObject val in spawnableMapObjects)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<Turret>() != (Object)null)
				{
					val.numberToSpawn = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0f, (float)Random.Range(LethalEventsState.Config.MinMines.Value, LethalEventsState.Config.MaxMines.Value)),
						new Keyframe(1f, 25f)
					});
				}
			}
		}
	}
	internal class NoneEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LELogger.Mls.LogMessage((object)"Nothing happens");
		}
	}
	internal class SlimeCityEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LethalEventHandler.SetEnemiesRarity<BlobAI>(currentLevel);
		}
	}
	internal class SnareFleaEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			LethalEventHandler.SetEnemiesRarity<CentipedeAI>(currentLevel);
		}
	}
	internal class MineHellEvent : ILethalEvent
	{
		void ILethalEvent.Execute(SelectableLevel currentLevel)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			SpawnableMapObject[] spawnableMapObjects = currentLevel.spawnableMapObjects;
			foreach (SpawnableMapObject val in spawnableMapObjects)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<Landmine>() != (Object)null)
				{
					val.numberToSpawn = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0f, (float)Random.Range(LethalEventsState.Config.MinTurrets.Value, LethalEventsState.Config.MaxTurrets.Value)),
						new Keyframe(1f, 25f)
					});
				}
			}
		}
	}
}
namespace LethalEvents.Configuration
{
	internal static class LethalConfig
	{
		private static string _generalSection = "1. General Settings";

		private static string _turretHellSection = "2. Turret Hell";

		private static string _mineHellSection = "3. Mine Hell";

		private static string _arachnophobiaSection = "4. Arachnophobia";

		private static string _slimeCitySection = "5. Arachnophobia";

		private static string _snareFleasSection = "6. Snare Fles";

		private static string _brackenAndCoildheadSection = "7. Bracken And Coilhead";

		private static string _lootbugHavenSection = "8. Lootbug Haven";

		private static string _deliverySection = "9. Delivery";

		internal static LethalConfigDTO BindConfigSettings()
		{
			LethalConfigDTO lethalConfigDTO = new LethalConfigDTO();
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.None, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_generalSection, "EnableNoneEvent", true, "Enable 'None' event"));
			lethalConfigDTO.MaxEnemyPowerIncrement = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_generalSection, "MaxEnemyPowerIncrement", 5, "Additional available enemy power, added to every map (Most noticeable on early moons)");
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.TurretHell, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_turretHellSection, "EnableTurretHellEvent", true, "Enable 'Turret Hell' event (Spawns way too many turrets)"));
			lethalConfigDTO.MinTurrets = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_turretHellSection, "MinTurrets", 25, "Minimum amount of turrets during Turrent Hell event");
			lethalConfigDTO.MaxTurrets = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_turretHellSection, "MaxTurrets", 50, "Maximum amount of turrets during Turrent Hell event");
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.MineHell, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_mineHellSection, "EnableMineHellEvent", true, "Enable 'Mine Hell' event (Spawns way too many mines)"));
			lethalConfigDTO.MinMines = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_mineHellSection, "MinMines", 25, "Minimum amount of mines during Mine Hell event");
			lethalConfigDTO.MaxMines = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_mineHellSection, "MaxMines", 50, "Maximum amount of mines during Mine Hell event");
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.Arachnophobia, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_arachnophobiaSection, "EnableArachnophobiaEvent", true, "Enable 'Arachnophobia' event (Chance of enemies being spiders is drastically increased)"));
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.SlimeCity, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_slimeCitySection, "EnableSlimeCityEvent", true, "Enable 'Slime City' event (Chance of enemies being slimes is drastically increased)"));
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.SnareFleas, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_snareFleasSection, "EnableSnareFleasEvent", true, "Enable 'Snare Fleas' event (Chance of enemies being snare fleas is drastically increased)"));
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.BrackenAndCoilhead, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_brackenAndCoildheadSection, "EnableBrackenAndCoilheadEvent", true, "Enable 'BrackenAndCoilhead' event (Chance of enemies being bracken and coilheads is drastically increased)"));
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.LootbugHaven, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_lootbugHavenSection, "EnableLootbugHavenEvent", true, "Enable 'LootbugHaven' event (Chance of enemies being lootbugs is drastically increased)"));
			lethalConfigDTO.LethalEventIsEnabled.Add(LethalEvent.Delivery, ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<bool>(_deliverySection, "EnableDeliveryEvent", true, "Enable 'Delivery' event (Delivers free items from the vanilla shop)"));
			lethalConfigDTO.ChanceForHighTierDeliveryItems = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_deliverySection, "ChanceForHighTierDeliverItems", 10, "Chance for a delivery item to be a high tier items during 'Delivery' event. (From 0-100%)");
			lethalConfigDTO.MinDeliveryItems = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_deliverySection, "MinDeliveryItems", 3, "Minimum amount of items delivered during 'Delivery' event");
			lethalConfigDTO.MaxDeliveryItems = ((BaseUnityPlugin)LethalEvents.Instance).Config.Bind<int>(_deliverySection, "MaxDeliveryItems", 8, "Maximum amount of items delivered during 'Delivery' event");
			return lethalConfigDTO;
		}
	}
	internal class LethalConfigDTO
	{
		public Dictionary<LethalEvent, ConfigEntry<bool>> LethalEventIsEnabled { get; set; } = new Dictionary<LethalEvent, ConfigEntry<bool>>();


		public ConfigEntry<int> MaxEnemyPowerIncrement { get; set; }

		public ConfigEntry<int> MinTurrets { get; set; }

		public ConfigEntry<int> MaxTurrets { get; set; }

		public ConfigEntry<int> MinMines { get; set; }

		public ConfigEntry<int> MaxMines { get; set; }

		public ConfigEntry<int> ChanceForHighTierDeliveryItems { get; set; }

		public ConfigEntry<int> MinDeliveryItems { get; set; }

		public ConfigEntry<int> MaxDeliveryItems { get; set; }
	}
}
namespace LethalEvents.Common
{
	internal static class EnumExtensions
	{
		internal static string GetDescription(this Enum value)
		{
			Type type = value.GetType();
			string name = Enum.GetName(type, value);
			if (name != null)
			{
				FieldInfo field = type.GetField(name);
				if (field != null && Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) is DescriptionAttribute descriptionAttribute)
				{
					return descriptionAttribute.Description;
				}
			}
			return null;
		}
	}
	internal static class LELogger
	{
		internal static ManualLogSource Mls { get; set; }
	}
	internal static class LethalEventHandler
	{
		private const int MOON_HEAT_MODIFIER = 20;

		private const float ENEMY_EVENT_SPAWN_MULTIPIER = 5f;

		internal static ILethalEvent GetLethalEventExecutor(LethalEvent lethalEvent)
		{
			return lethalEvent switch
			{
				LethalEvent.None => new NoneEvent(), 
				LethalEvent.TurretHell => new TurretHellEvent(), 
				LethalEvent.MineHell => new MineHellEvent(), 
				LethalEvent.Arachnophobia => new ArachnophobiaEvent(), 
				LethalEvent.SnareFleas => new SnareFleaEvent(), 
				LethalEvent.BrackenAndCoilhead => new BrackenAndCoilEvent(), 
				LethalEvent.SlimeCity => new SlimeCityEvent(), 
				LethalEvent.LootbugHaven => new LootbugHavenEvent(), 
				LethalEvent.Delivery => new DeliveryEvent(), 
				_ => new NoneEvent(), 
			};
		}

		internal static LethalEvent GetRandomLethalEvent(SelectableLevel currentLevel)
		{
			if (!LethalEventsState.Config.LethalEventIsEnabled.Where((KeyValuePair<LethalEvent, ConfigEntry<bool>> x) => x.Value.Value).Any())
			{
				return LethalEvent.None;
			}
			if (Random.Range(0, 100) >= LethalEventsState.MoonHeat[currentLevel.levelID] && LethalEventsState.Config.LethalEventIsEnabled[LethalEvent.None].Value)
			{
				return LethalEvent.None;
			}
			LethalEvent lethalEvent = (LethalEvent)Random.Range(0, Enum.GetValues(typeof(LethalEvent)).Length);
			while (!LethalEventsState.Config.LethalEventIsEnabled[lethalEvent].Value)
			{
				lethalEvent = (LethalEvent)Random.Range(0, Enum.GetValues(typeof(LethalEvent)).Length);
			}
			return lethalEvent;
		}

		internal static void LogLethalEventName(LethalEvent lethalEvent)
		{
			LELogger.Mls.LogMessage((object)$"Current Event: {lethalEvent}");
			HUDManager.Instance.AddTextToChatOnServer("<color=orange>CURRENT EVENT: " + lethalEvent.GetDescription(), -1);
		}

		internal static void LogCurrentMoonHeat(SelectableLevel currentLevel)
		{
			LELogger.Mls.LogMessage((object)$"Current Moon Heat: {LethalEventsState.MoonHeat[currentLevel.levelID]}");
			HUDManager.Instance.AddTextToChatOnServer($"<color=purple>Current Moon Heat: {LethalEventsState.MoonHeat[currentLevel.levelID]}", -1);
		}

		internal static void NormalizeLevel(SelectableLevel currentLevel)
		{
			NormalizeMoon(currentLevel);
			NormalizeEnemiesRarities(currentLevel);
			NormalizeSpawnableMapObjectsCurves(currentLevel);
		}

		internal static void NormalizeMoon(SelectableLevel currentLevel)
		{
			if (!LethalEventsState.OriginalMaxEnemyPowerCount.ContainsKey(currentLevel))
			{
				LethalEventsState.OriginalMaxEnemyPowerCount[currentLevel] = currentLevel.maxEnemyPowerCount;
			}
			else
			{
				currentLevel.maxEnemyPowerCount = LethalEventsState.OriginalMaxEnemyPowerCount[currentLevel];
			}
		}

		internal static void NormalizeEnemiesRarities(SelectableLevel currentLevel)
		{
			if (!LethalEventsState.OriginalEnemiesRarities.ContainsKey(currentLevel))
			{
				List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>(((IEnumerable<SpawnableEnemyWithRarity>)currentLevel.Enemies).Select((Func<SpawnableEnemyWithRarity, SpawnableEnemyWithRarity>)((SpawnableEnemyWithRarity e) => new SpawnableEnemyWithRarity
				{
					enemyType = e.enemyType,
					rarity = e.rarity
				})));
				Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>> originalEnemiesRarities = LethalEventsState.OriginalEnemiesRarities;
				List<SpawnableEnemyWithRarity> list2 = new List<SpawnableEnemyWithRarity>(list.Count);
				foreach (SpawnableEnemyWithRarity item in list)
				{
					list2.Add(item);
				}
				originalEnemiesRarities[currentLevel] = list2;
				return;
			}
			foreach (SpawnableEnemyWithRarity enemy in currentLevel.Enemies)
			{
				SpawnableEnemyWithRarity val = ((IEnumerable<SpawnableEnemyWithRarity>)LethalEventsState.OriginalEnemiesRarities[currentLevel]).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName == enemy.enemyType.enemyName));
				if (val != null)
				{
					enemy.rarity = val.rarity;
				}
			}
		}

		internal static void NormalizeSpawnableMapObjectsCurves(SelectableLevel currentLevel)
		{
			if (!LethalEventsState.OriginalMapObjectCurve.ContainsKey(currentLevel))
			{
				List<SpawnableMapObject> list = new List<SpawnableMapObject>(((IEnumerable<SpawnableMapObject>)currentLevel.spawnableMapObjects).Select((Func<SpawnableMapObject, SpawnableMapObject>)((SpawnableMapObject e) => new SpawnableMapObject
				{
					prefabToSpawn = e.prefabToSpawn,
					numberToSpawn = e.numberToSpawn
				})));
				Dictionary<SelectableLevel, List<SpawnableMapObject>> originalMapObjectCurve = LethalEventsState.OriginalMapObjectCurve;
				List<SpawnableMapObject> list2 = new List<SpawnableMapObject>(list.Count);
				foreach (SpawnableMapObject item in list)
				{
					list2.Add(item);
				}
				originalMapObjectCurve[currentLevel] = list2;
				return;
			}
			SpawnableMapObject[] spawnableMapObjects = currentLevel.spawnableMapObjects;
			foreach (SpawnableMapObject mapObject in spawnableMapObjects)
			{
				SpawnableMapObject val = ((IEnumerable<SpawnableMapObject>)LethalEventsState.OriginalMapObjectCurve[currentLevel]).FirstOrDefault((Func<SpawnableMapObject, bool>)((SpawnableMapObject x) => ((Object)x.prefabToSpawn).name == ((Object)mapObject.prefabToSpawn).name));
				if (val != null)
				{
					mapObject.numberToSpawn = val.numberToSpawn;
				}
			}
		}

		internal static void HandleMoonHeat(SelectableLevel currentLevel)
		{
			if (!LethalEventsState.MoonHeat.ContainsKey(currentLevel.levelID))
			{
				LethalEventsState.MoonHeat.Add(currentLevel.levelID, 0);
			}
			foreach (KeyValuePair<int, int> item in LethalEventsState.MoonHeat.ToList())
			{
				if (item.Key == currentLevel.levelID)
				{
					LethalEventsState.MoonHeat[item.Key] += 20;
					if (LethalEventsState.MoonHeat[item.Key] > 100)
					{
						LethalEventsState.MoonHeat[item.Key] = 100;
					}
				}
				else
				{
					LethalEventsState.MoonHeat[item.Key] -= 20;
					if (LethalEventsState.MoonHeat[item.Key] < 0)
					{
						LethalEventsState.MoonHeat[item.Key] = 0;
					}
				}
			}
		}

		internal static void SetEnemiesRarity<T>(SelectableLevel currentLevel) where T : EnemyAI
		{
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0183: Expected O, but got Unknown
			LELogger.Mls.LogMessage((object)$"MoonHeat: {LethalEventsState.MoonHeat[currentLevel.levelID]} | MoonHeatModifier: {20} | Divided: {LethalEventsState.MoonHeat[currentLevel.levelID] / 20}");
			float num = 5f * (float)(LethalEventsState.MoonHeat[currentLevel.levelID] / 20);
			LELogger.Mls.LogMessage((object)$"Enemy Multiplier: {num}");
			for (int i = 0; i < currentLevel.Enemies.Count; i++)
			{
				SpawnableEnemyWithRarity val = currentLevel.Enemies[i];
				if ((Object)(object)val.enemyType.enemyPrefab.GetComponent<T>() != (Object)null)
				{
					int rarity = val.rarity;
					SpawnableEnemyWithRarity obj = currentLevel.Enemies[i];
					obj.rarity += (int)Math.Round((float)rarity * num);
					currentLevel.Enemies[i].enemyType.MaxCount = (int)Math.Round((float)rarity * num);
					float[] array = new float[2]
					{
						1f,
						40f + num
					};
					float[] array2 = new float[2]
					{
						100f,
						100f + num
					};
					Keyframe[] array3 = (Keyframe[])(object)new Keyframe[array.Length];
					for (int j = 0; j < array.Length; j++)
					{
						array3[j] = new Keyframe(array[j], array2[j]);
					}
					currentLevel.Enemies[i].enemyType.probabilityCurve = new AnimationCurve(array3);
				}
			}
		}
	}
	internal static class LethalEventsState
	{
		internal static Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>> OriginalEnemiesRarities { get; set; } = new Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>>();


		internal static Dictionary<SelectableLevel, List<SpawnableMapObject>> OriginalMapObjectCurve { get; set; } = new Dictionary<SelectableLevel, List<SpawnableMapObject>>();


		internal static Dictionary<SelectableLevel, int> OriginalMaxEnemyPowerCount { get; set; } = new Dictionary<SelectableLevel, int>();


		internal static Dictionary<int, int> MoonHeat { get; set; } = new Dictionary<int, int>();


		internal static bool IsHost { get; set; } = false;


		internal static bool EnableGod { get; set; } = false;


		internal static bool EnableNightVision { get; set; } = false;


		internal static bool EnableInfiniteSprint { get; set; } = false;


		internal static LethalConfigDTO Config { get; set; }
	}
}