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 BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using BrutalEvent.Common;
using BrutalEvent.Enums;
using BrutalEvent.Models;
using BrutalEvent.Services;
using BrutalEvent.Services.Abstract;
using BrutalEvent.Services.Abstract.Interface;
using BrutalEvent.Services.Events;
using HarmonyLib;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("BrutalEvent")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("BrutalEvent")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0a74de6b-63ee-4bb8-93f7-ed2e9b5480b9")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace BrutalEvent
{
	[HarmonyPatch(typeof(TimeOfDay), "Awake")]
	public class QuotaAjuster
	{
		[HarmonyPostfix]
		private static void Prefix(TimeOfDay __instance)
		{
			Configuration.mls.LogWarning((object)"Changing quota variables in patch!");
			__instance.quotaVariables.startingQuota = Plugin._config.StartingQuota.Value;
			__instance.quotaVariables.startingCredits = Plugin._config.StartingCredits.Value;
			__instance.quotaVariables.baseIncrease = Plugin._config.BaseIncrease.Value;
			__instance.quotaVariables.deadlineDaysAmount = Plugin._config.DeadlineDaysAmount.Value;
		}
	}
	[BepInPlugin("Liquid.BetterBrutalEvent", "BetterBrutalEvent", "1.0.0")]
	public class Plugin : BaseUnityPlugin
	{
		private const string MyGUID = "Liquid.BetterBrutalEvent";

		private const string PluginName = "BetterBrutalEvent";

		private const string VersionString = "1.0.0";

		private Harmony _harmony = new Harmony("BetterBrutalEvent");

		public static ConfigValues _config;

		private static EventFactory _eventFactory;

		private static MasterEnviroment _masterEnviroment;

		public static Plugin Instance { get; set; }

		private void Awake()
		{
			Instance = this;
			_config = new LoadConfig().BindConfigSettings();
			_eventFactory = new EventFactory();
			_masterEnviroment = new MasterEnviroment();
			Configuration.mls = Logger.CreateLogSource("BrutalEvent");
			_harmony.PatchAll(typeof(Plugin));
			Configuration.mls = ((BaseUnityPlugin)this).Logger;
			Configuration.mls.LogInfo((object)"Loaded NEW Brutal Company and applying patches.");
		}

		[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
		[HarmonyPrefix]
		private static bool ModifyLevel(ref SelectableLevel newLevel)
		{
			ShowLogo();
			if (!((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				Configuration.mls.LogWarning((object)" YOU ARE NOT A HOST! (>_<)");
				Configuration.mls.LogWarning((object)" BRUTAL EVENT DIDN'T LOADING");
				return false;
			}
			Configuration.RarityLevelValue.TryGetValue(newLevel, out var value);
			Configuration.mls.LogInfo((object)"NORMALIZATION ENEMIES");
			_masterEnviroment.NormalizeEnemiesRarity(newLevel);
			Configuration.mls.LogInfo((object)"GENERATE EVENT");
			LevelEvent levelEvent = ((newLevel.sceneName == "CompanyBuilding") ? _eventFactory.CreateEvent(EventEnum.None) : _eventFactory.GetRandomEvent());
			_masterEnviroment.SetupRateLimit(newLevel, _eventFactory.EventEnum, _config);
			UpdateHUDAndCredits(newLevel, value);
			Configuration.mls.LogInfo((object)"SETUP SCRAP LIMIT");
			_masterEnviroment.SetupLevelScrap(newLevel, _config);
			Configuration.mls.LogInfo((object)"ON LOAD NEW LEVEL");
			levelEvent.OnLoadNewLevel(ref newLevel, _config, value);
			Configuration.mls.LogInfo((object)"RARITY BY LEVEL[newLevel]");
			Configuration.RarityLevelValue[newLevel] = Mathf.Clamp(value + 15f, 0f, _config.MaxRate.Value);
			HUDManager.Instance.AddTextToChatOnServer(levelEvent.GetEventName() ?? "", -1);
			Configuration.mls.LogWarning((object)("EVENT : " + levelEvent.GetEventName()));
			Configuration.mls.LogInfo((object)"ShowEnemyRarirty");
			_masterEnviroment.ShowEnemyRarirty(newLevel, value);
			return true;
		}

		private static void UpdateHUDAndCredits(SelectableLevel newLevel, float currentEventRate)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			HUDManager.Instance.AddTextToChatOnServer($"<color=yellow>MOON IS AT {currentEventRate} %RATE</color>", -1);
			if (currentEventRate > _config.LimitRate.Value)
			{
				HUDManager.Instance.AddTextToChatOnServer($"<color=red>HEAT LEVEL IS DANGEROUSLY HIGH : {currentEventRate} " + "<color=white>\nVISIT OTHER MOONS TO LOWER HEAT LEVEL.</color>", -1);
			}
			if (!newLevel.sceneName.Contains("CompanyBuilding"))
			{
				Terminal val = (Terminal)(((object)Object.FindObjectOfType<Terminal>()) ?? ((object)new Terminal()));
				val.groupCredits += _config.AddCredits.Value;
				val.SyncGroupCreditsServerRpc(val.groupCredits, val.numberOfItemsInDropship);
			}
		}

		public static void ShowLogo()
		{
			Configuration.mls.LogInfo((object)"\r\n______      _   _             ______            _        _   _____                _   \r\n| ___ \\    | | | |            | ___ \\          | |      | | |  ___|              | |  \r\n| |_/ / ___| |_| |_ ___ _ __  | |_/ /_ __ _   _| |_ __ _| | | |____   _____ _ __ | |_ \r\n| ___ \\/ _ \\ __| __/ _ \\ '__| | ___ \\ '__| | | | __/ _` | | |  __\\ \\ / / _ \\ '_ \\| __|\r\n| |_/ /  __/ |_| ||  __/ |    | |_/ / |  | |_| | || (_| | | | |___\\ V /  __/ | | | |_ \r\n\\____/ \\___|\\__|\\__\\___|_|    \\____/|_|   \\__,_|\\__\\__,_|_| \\____/ \\_/ \\___|_| |_|\\__|\r\n                                                                                      \r\n                                                                                      \r\n");
		}

		private static void Update()
		{
		}
	}
}
namespace BrutalEvent.Services
{
	public class EventFactory : IEventFactory
	{
		private Random random = new Random();

		public EventEnum EventEnum { get; set; } = EventEnum.None;


		public LevelEvent GetRandomEvent()
		{
			EventEnum = (EventEnum)random.Next(Enum.GetValues(typeof(EventEnum)).Length);
			return CreateEvent(EventEnum);
		}

		public LevelEvent GetCustomEvent(EventEnum eventEnum)
		{
			return CreateEvent(eventEnum);
		}

		public LevelEvent CreateEvent(EventEnum gameEvent)
		{
			if (1 == 0)
			{
			}
			LevelEvent result = gameEvent switch
			{
				EventEnum.None => new NoneEvent(), 
				EventEnum.All => new AllEvent(), 
				EventEnum.Chaos => new ChaosEvent(), 
				EventEnum.Unfair => new UnFairEvent(), 
				EventEnum.Landmine => new LandMineEvent(), 
				EventEnum.Kleptomania => new KleptomaniaEvent(), 
				EventEnum.Arachnophobia => new ArachnophobiaEvent(), 
				EventEnum.SecuritySystem => new SecurityEvent(), 
				EventEnum.AllSnareFlea => new AllSnareEvent(), 
				EventEnum.BrackenAndCoil => new BrackerAndCoilEvent(), 
				EventEnum.BlobApocalypsis => new BlobApocalypsis(), 
				EventEnum.WhoLetTheDogsOut => new WhoLetTheDogEvent(), 
				EventEnum.DidYouSeeHer => new DidYouSeeHerEvent(), 
				EventEnum.Tremors => new TremorsEvent(), 
				EventEnum.GoToRent => new GoToRentEvent(), 
				EventEnum.Delivery => new DeliveryEvent(), 
				EventEnum.LetsFly => new LetsFlyEvent(), 
				EventEnum.ReplaceItems => new ReplaceItemsEvent(), 
				_ => new NoneEvent(), 
			};
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class NormalDistributionService : INormalDistributionService
	{
		public float CalculateRarity(SelectableLevel currentLevel, float currentRate)
		{
			int count = RoundManager.Instance.playersManager.ClientPlayerList.Count;
			float num = (float)Math.Pow(Math.PI, count);
			float mu = currentRate + (float)count * num;
			float sigma = currentRate / (float)count;
			float num2 = NormalDistribution(mu, sigma, count);
			return Mathf.Clamp(num2, 0f, 100f);
		}

		public float NormalDistribution(float mu, float sigma, int players)
		{
			float num = 0f;
			List<float> list = new List<float>();
			for (int i = 0; i < players; i++)
			{
				list.Add(Random.Range(0f, 1f));
				num += list.LastOrDefault();
			}
			float num2 = num - list.Sum() / (float)list.Count;
			return mu + sigma * num2;
		}
	}
}
namespace BrutalEvent.Services.Events
{
	internal class AllEvent : LevelEvent
	{
		private EventFactory eventFactory;

		public AllEvent()
		{
			eventFactory = new EventFactory();
		}

		public override string GetEventName()
		{
			return "<color=red>LEAVE THIS MOON! NOW!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new AllEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			foreach (object value in Enum.GetValues(typeof(EventEnum)))
			{
				eventFactory.CreateEvent((EventEnum)value);
			}
		}
	}
	internal class AllSnareEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=orange>WATCH YOUR HEAD!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new AllSnareEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<CentipedeAI>(newLevel, currentRate, 2f);
		}

		public override void OnLoadNewLevelCleanup(ref SelectableLevel newLevel)
		{
			newLevel.enemySpawnChanceThroughoutDay = oldAnimationCurve;
		}
	}
	internal class ArachnophobiaEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>ARACHNOPHOBIA!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new ArachnophobiaEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<SandSpiderAI>(newLevel, currentRate, 2f);
		}
	}
	internal class BlobApocalypsis : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=orange>BLOBAPOCALYPSIS</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new BlobApocalypsis();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<BlobAI>(newLevel, currentRate, 3f);
		}
	}
	internal class BrackerAndCoilEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>THE HUNT BEGIN!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new BrackerAndCoilEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.ResetEnemiesRarity(newLevel);
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<FlowermanAI>(newLevel, currentRate, 2f);
			_enviroment.GenerateEnemiesEvent<CrawlerAI>(newLevel, currentRate, 2f);
		}
	}
	internal class ChaosEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>LEAVE THIS MOON! CHAOS!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new ChaosEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<FlowermanAI>(newLevel, currentRate, 1f);
			_enviroment.GenerateEnemiesEvent<BlobAI>(newLevel, currentRate, 1f);
			_enviroment.GenerateEnemiesEvent<SandSpiderAI>(newLevel, currentRate, 1f);
			_enviroment.GenerateEnemiesEvent<CentipedeAI>(newLevel, currentRate, 1f);
			_enviroment.GenerateEnemiesEvent<CrawlerAI>(newLevel, currentRate, 1f);
			_enviroment.GenerateEnemiesEvent<HoarderBugAI>(newLevel, currentRate, 2f);
			_enviroment.GenerateEnemiesEvent<SpringManAI>(newLevel, currentRate, 1f);
		}
	}
	internal class DeliveryEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=green>EZ DELIVERY!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new DeliveryEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			Terminal val = Object.FindObjectOfType<Terminal>();
			int num = Random.Range(3, 9);
			for (int i = 0; i < num; i++)
			{
				int item = Random.Range(0, 6);
				val.orderedItemsFromTerminal.Add(item);
			}
		}
	}
	internal class DidYouSeeHerEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>DID YOU SEE HER?!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new DidYouSeeHerEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<DressGirlAI>(newLevel, currentRate, 1f);
		}
	}
	internal class GoToRentEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=green>GO TO RENT!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new GoToRentEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			Terminal val = Object.FindObjectOfType<Terminal>();
			Item[] buyableItemsList = val.buyableItemsList;
			foreach (Item val2 in buyableItemsList)
			{
				val2.creditsWorth += (int)((double)currentRate + (double)val2.creditsWorth * 0.5);
			}
		}
	}
	internal class KleptomaniaEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=orange>KLEPTOMANIA!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new KleptomaniaEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			_enviroment.GenerateEnemiesEvent<HoarderBugAI>(newLevel, currentRate, 2.5f);
		}
	}
	internal class LandMineEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>MINE MINE MINE!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new LandMineEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			SpawnableMapObject[] spawnableMapObjects = newLevel.spawnableMapObjects;
			foreach (SpawnableMapObject val in spawnableMapObjects)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<Landmine>() != (Object)null)
				{
					val.numberToSpawn = _curveGenerator.CreateSpawnCurve(new float[2]
					{
						0f,
						25f * configs.Multiplier.Value
					}, new float[2]
					{
						100f,
						500f + currentRate * 3f
					});
				}
			}
		}
	}
	internal class LetsFlyEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=green>ITS A FLY?! NO ITS A PLANE!</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new LetsFlyEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			int item = 9;
			Terminal val = Object.FindObjectOfType<Terminal>();
			for (int i = 0; i < 5; i++)
			{
				val.orderedItemsFromTerminal.Add(item);
			}
		}
	}
	public class NoneEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=green>NONE EVENT</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new NoneEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.NormalizeEnemiesRarity(newLevel);
		}
	}
	internal class ReplaceItemsEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=orange>DID YOU BUY FLASHLIGHT? RIGHT?</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new ReplaceItemsEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			Terminal val = Object.FindObjectOfType<Terminal>();
			int num = val.buyableItemsList.Length;
			Item[] array = val.buyableItemsList.ToArray();
			val.buyableItemsList = null;
			for (int num2 = num; num2 > 0; num2--)
			{
				CollectionExtensions.AddItem<Item>((IEnumerable<Item>)val.buyableItemsList, array[num2]);
			}
		}
	}
	internal class SecurityEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=orange>COMPANY SECURITY SYSTEM! GLHF :)</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new SecurityEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupEnemyChance(newLevel, currentRate, configs.Multiplier.Value);
			SpawnableMapObject[] spawnableMapObjects = newLevel.spawnableMapObjects;
			SpawnableMapObject[] array = spawnableMapObjects;
			foreach (SpawnableMapObject val in array)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<Turret>() != (Object)null)
				{
					val.numberToSpawn = _curveGenerator.CreateSpawnCurve(new float[2]
					{
						0f,
						25f + currentRate
					}, new float[2]
					{
						100f,
						100f + currentRate * 3f
					});
				}
			}
		}
	}
	internal class TremorsEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>DID YOU SAW THIS MOVIE?)</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new TremorsEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			SpawnableMapObject[] spawnableMapObjects = newLevel.spawnableMapObjects;
			for (int i = 0; i < newLevel.outsideEnemySpawnChanceThroughDay.length; i++)
			{
				if (newLevel.OutsideEnemies[i].enemyType.enemyName != "SandWormAI")
				{
					newLevel.OutsideEnemies[i].rarity = 0;
				}
			}
			SpawnableMapObject[] array = spawnableMapObjects;
			foreach (SpawnableMapObject val in array)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<SandWormAI>() != (Object)null)
				{
					val.numberToSpawn = _curveGenerator.CreateSpawnCurve(new float[2] { 0f, 15f }, new float[2]
					{
						0.5f,
						50f + currentRate * 3f
					});
				}
			}
		}
	}
	internal class UnFairEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=green>THIS IS UNFAIR! :(</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new UnFairEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			_enviroment.SetupLevelScrap(newLevel, configs, 2.5f);
			_enviroment.ResetEnemiesRarity(newLevel);
		}
	}
	internal class WhoLetTheDogEvent : LevelEvent
	{
		public override string GetEventName()
		{
			return "<color=red>WHO LET THE DOGS OUT, WOOF WOOF</color>";
		}

		public override LevelEvent CreateEvent()
		{
			return new WhoLetTheDogEvent();
		}

		public override void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate)
		{
			SpawnableMapObject[] spawnableMapObjects = newLevel.spawnableMapObjects;
			for (int i = 0; i < newLevel.outsideEnemySpawnChanceThroughDay.length; i++)
			{
				if (newLevel.OutsideEnemies[i].enemyType.enemyName != "MouthDogAI")
				{
					newLevel.OutsideEnemies[i].rarity = 0;
				}
			}
			SpawnableMapObject[] array = spawnableMapObjects;
			foreach (SpawnableMapObject val in array)
			{
				if ((Object)(object)val.prefabToSpawn.GetComponentInChildren<MouthDogAI>() != (Object)null)
				{
					val.numberToSpawn = _curveGenerator.CreateSpawnCurve(new float[2] { 0f, 50f }, new float[2]
					{
						100f,
						100f + currentRate * 3f
					});
				}
			}
		}
	}
}
namespace BrutalEvent.Services.Abstract
{
	public class MasterEnviroment
	{
		private const int AdditionalMaxScrap = 45;

		private const int MaxEnemyPowerIncrement = 10;

		private const int MaxOutsideEnemyPowerIncrement = 5;

		private const int MaxDaytimeEnemyPowerIncrement = 10;

		private readonly SpawnCurveGenerator _curveGenerator;

		public MasterEnviroment()
		{
			_curveGenerator = new SpawnCurveGenerator();
		}

		public void GenerateEnemiesEvent<T>(SelectableLevel currentLevel, float currentRate, float multiplier = 1f) where T : EnemyAI
		{
			if (multiplier < 1f || multiplier > 3f)
			{
				multiplier = 1f;
			}
			currentRate = ((currentRate == 0f) ? 1f : currentRate);
			float num = new NormalDistributionService().CalculateRarity(currentLevel, currentRate);
			for (int i = 0; i < currentLevel.Enemies.Count; i++)
			{
				SpawnableEnemyWithRarity enemy = currentLevel.Enemies[i];
				if ((Object)(object)enemy.enemyType.enemyPrefab.GetComponent<T>() != (Object)null)
				{
					int rarity = ((IEnumerable<SpawnableEnemyWithRarity>)Configuration.OriginalEnemiesRarities[currentLevel]).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName.Equals(enemy.enemyType.enemyName))).rarity;
					enemy.rarity = (int)(num * multiplier) + rarity;
					EnemyType enemyType = enemy.enemyType;
					enemyType.MaxCount += (int)(num * multiplier);
					enemy.enemyType.probabilityCurve = _curveGenerator.CreateSpawnCurve(new float[2]
					{
						0f,
						40f + multiplier * currentRate
					}, new float[2]
					{
						100f,
						100f + multiplier * currentRate + (float)rarity
					});
				}
			}
		}

		public void NormalizeEnemiesRarity(SelectableLevel currentLevel, List<string> typesEnemyCollection = null)
		{
			if (!Configuration.OriginalEnemiesRarities.ContainsKey(currentLevel))
			{
				Configuration.mls.LogInfo((object)"START METHOD NORMALIZATION ENEMIES");
				List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>(((IEnumerable<SpawnableEnemyWithRarity>)currentLevel.Enemies).Select((Func<SpawnableEnemyWithRarity, SpawnableEnemyWithRarity>)((SpawnableEnemyWithRarity e) => new SpawnableEnemyWithRarity
				{
					enemyType = e.enemyType,
					rarity = e.rarity
				})));
				Configuration.mls.LogInfo((object)$"ORIGINAL ENEMIES : {list.Count}");
				Configuration.OriginalEnemiesRarities[currentLevel] = list;
			}
			Configuration.mls.LogInfo((object)"MID METHOD NORMALIZATION ENEMIES");
			List<SpawnableEnemyWithRarity> source = Configuration.OriginalEnemiesRarities[currentLevel];
			foreach (SpawnableEnemyWithRarity enemy in currentLevel.Enemies)
			{
				if (typesEnemyCollection == null || typesEnemyCollection.Contains(enemy.enemyType.enemyName))
				{
					SpawnableEnemyWithRarity val = ((IEnumerable<SpawnableEnemyWithRarity>)source).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => x.enemyType.enemyName == enemy.enemyType.enemyName));
					if (val != null)
					{
						enemy.rarity = val.rarity;
					}
				}
			}
		}

		public void ResetEnemiesRarity(SelectableLevel currentLevel, List<string> typesEnemyCollection = null)
		{
			HashSet<string> hashSet = ((typesEnemyCollection != null) ? new HashSet<string>(typesEnemyCollection) : null);
			foreach (SpawnableEnemyWithRarity enemy in currentLevel.Enemies)
			{
				if (hashSet == null || hashSet.Contains(enemy.enemyType.enemyName))
				{
					enemy.rarity = 0;
				}
			}
		}

		public void SetupRateLimit(SelectableLevel currentLevel, EventEnum eventEnum, ConfigValues config)
		{
			if (!Configuration.RarityLevelValue.ContainsKey(currentLevel))
			{
				Configuration.RarityLevelValue.Add(currentLevel, 0f);
			}
			if (Configuration.Enemies == null)
			{
				Configuration.Enemies = new Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>>();
			}
			if (!Configuration.Enemies.ContainsKey(currentLevel))
			{
				Configuration.mls.LogInfo((object)("Initializing enemies for level " + (((currentLevel != null) ? ((Object)currentLevel).name : null) ?? "NULL")));
				List<SpawnableEnemyWithRarity> value = currentLevel?.Enemies?.Select((Func<SpawnableEnemyWithRarity, SpawnableEnemyWithRarity>)((SpawnableEnemyWithRarity enemy) => new SpawnableEnemyWithRarity
				{
					enemyType = enemy.enemyType,
					rarity = enemy.rarity
				})).ToList() ?? new List<SpawnableEnemyWithRarity>();
				Configuration.Enemies[currentLevel] = value;
			}
			Configuration.Enemies[currentLevel] = ((IEnumerable<SpawnableEnemyWithRarity>)Configuration.Enemies[currentLevel]).Select((Func<SpawnableEnemyWithRarity, SpawnableEnemyWithRarity>)((SpawnableEnemyWithRarity enemy) => new SpawnableEnemyWithRarity
			{
				enemyType = enemy.enemyType,
				rarity = enemy.rarity
			})).ToList();
			foreach (SelectableLevel item in Configuration.RarityLevelValue.Keys.ToList())
			{
				if (Configuration.RarityLevelValue.TryGetValue(item, out var value2))
				{
					float value3 = Mathf.Clamp(value2, config.RarityMin.Value, config.RarityMax.Value);
					if (eventEnum == EventEnum.All)
					{
						Configuration.RarityLevelValue[item] = 0f;
					}
					else
					{
						Configuration.RarityLevelValue[item] = value3;
					}
				}
			}
		}

		public SelectableLevel SetupLevelScrap(SelectableLevel newLevel, ConfigValues config, float multiplier = 1f)
		{
			if (!Configuration.levelsModified.Contains(newLevel))
			{
				Configuration.levelsModified.Add(newLevel);
				ModifyDaySettings(newLevel, config, multiplier);
			}
			return newLevel;
		}

		public void ModifyDaySettings(SelectableLevel level, ConfigValues config, float multiplier = 1f)
		{
			level.maxScrap += (int)(45f * multiplier);
			level.maxTotalScrapValue += (int)(Random.Range(config.MinScrap.Value, config.MaxScrap.Value) * multiplier);
			level.maxEnemyPowerCount += 10;
			level.maxOutsideEnemyPowerCount += 5;
			level.maxDaytimeEnemyPowerCount += 10;
		}

		public void ShowEnemyRarirty(SelectableLevel newLevel, float currentEventRate)
		{
			Configuration.mls.LogWarning((object)("|" + new string('-', 4) + "All ENEMIES RARITY" + new string('-', 4) + "|"));
			Configuration.mls.LogWarning((object)$"| Current Rate: {currentEventRate}%         |");
			foreach (SpawnableEnemyWithRarity enemy in newLevel.Enemies)
			{
				Configuration.mls.LogInfo((object)$"| {enemy.enemyType.enemyName,17} : {enemy.rarity,-3}% |");
			}
			Configuration.mls.LogWarning((object)("|" + new string('-', 26) + "|"));
		}

		public SelectableLevel SetupEnemyChance(SelectableLevel newLevel, float currentEventRate, float multiplier = 1f)
		{
			if (multiplier < 1f || multiplier > 3f)
			{
				multiplier = 1f;
			}
			newLevel.daytimeEnemySpawnChanceThroughDay = _curveGenerator.CreateSpawnCurve(new float[2]
			{
				0f,
				1f * multiplier
			}, new float[2]
			{
				5f,
				25f + currentEventRate * multiplier
			});
			newLevel.enemySpawnChanceThroughoutDay = _curveGenerator.CreateSpawnCurve(new float[2]
			{
				0f,
				1f * multiplier
			}, new float[2]
			{
				0.4f,
				33f + currentEventRate * multiplier
			});
			newLevel.outsideEnemySpawnChanceThroughDay = _curveGenerator.CreateSpawnCurve(new float[2] { 0f, -10f }, new float[2]
			{
				0.8f,
				10f + currentEventRate
			});
			return newLevel;
		}
	}
	public class SpawnCurveGenerator
	{
		public AnimationCurve CreateSpawnCurve(float[] times, float[] values)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			if (times.Length != values.Length)
			{
				throw new ArgumentException("Times and values arrays must have the same length.");
			}
			Keyframe[] array = (Keyframe[])(object)new Keyframe[times.Length];
			for (int i = 0; i < times.Length; i++)
			{
				array[i] = new Keyframe(times[i], values[i]);
			}
			return new AnimationCurve(array);
		}
	}
	public abstract class LevelEvent
	{
		protected MasterEnviroment _enviroment;

		protected AnimationCurve oldAnimationCurve;

		protected readonly SpawnCurveGenerator _curveGenerator;

		public LevelEvent()
		{
			_enviroment = new MasterEnviroment();
			_curveGenerator = new SpawnCurveGenerator();
		}

		public abstract string GetEventName();

		public abstract LevelEvent CreateEvent();

		public abstract void OnLoadNewLevel(ref SelectableLevel newLevel, ConfigValues configs, float currentRate);

		public virtual void OnLoadNewLevelCleanup(ref SelectableLevel newLevel)
		{
		}

		public virtual bool IsValid(ref SelectableLevel newLevel)
		{
			return true;
		}
	}
}
namespace BrutalEvent.Services.Abstract.Interface
{
	public interface IEventFactory
	{
		LevelEvent CreateEvent(EventEnum eventEnum);
	}
	public interface INormalDistributionService
	{
		float CalculateRarity(SelectableLevel currentLevel, float currentRate);

		float NormalDistribution(float mu, float sigma, int players);
	}
}
namespace BrutalEvent.Models
{
	public class ConfigValues
	{
		public ConfigEntry<float> MinScrap { get; set; }

		public ConfigEntry<float> MaxScrap { get; set; }

		public ConfigEntry<float> LimitRate { get; set; }

		public ConfigEntry<float> MaxRate { get; set; }

		public ConfigEntry<float> RarityMin { get; set; }

		public ConfigEntry<float> RarityMax { get; set; }

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

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

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

		public ConfigEntry<float> BaseIncrease { get; set; }

		public ConfigEntry<float> Multiplier { get; set; }

		public ConfigEntry<int> DeadlineDaysAmount { get; set; }
	}
	public static class Configuration
	{
		public static bool loaded { get; set; }

		public static List<SelectableLevel> levelsModified { get; set; } = new List<SelectableLevel>();


		public static Dictionary<SelectableLevel, float> RarityLevelValue { get; set; } = new Dictionary<SelectableLevel, float>();


		public static Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>> Enemies { get; set; } = new Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>>();


		public static Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>> OriginalEnemiesRarities { get; set; } = new Dictionary<SelectableLevel, List<SpawnableEnemyWithRarity>>();


		public static ManualLogSource mls { get; set; }
	}
}
namespace BrutalEvent.Common
{
	public class LoadConfig
	{
		private string _sectionName = "BrutalEventSettings";

		public ConfigValues BindConfigSettings()
		{
			ConfigValues configValues = new ConfigValues();
			configValues.MinScrap = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "MinScrap", 250f, "MinScrap");
			configValues.MaxScrap = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "MaxScrap", 650f, "MaxScrap");
			configValues.LimitRate = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "LimitRate", 50f, "LimitRate");
			configValues.MaxRate = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "MaxRate", 100f, "MaxRate");
			configValues.RarityMin = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "RarityMin", 10f, "RarityMin");
			configValues.RarityMax = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName, "RarityMax", 100f, "RarityMax");
			configValues.AddCredits = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<int>(_sectionName, "AddCredits", 45, "Additional credits on each mission");
			configValues.StartingQuota = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<int>(_sectionName ?? "", "StartingQuota", 299, "StartingQuota Value");
			configValues.StartingCredits = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<int>(_sectionName ?? "", "StartingCredits", 150, "StartingCredits Value");
			configValues.BaseIncrease = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName ?? "", "BaseIncrease", 51f, "Increase Quota value each round");
			configValues.Multiplier = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<float>(_sectionName ?? "", "RandomizerMultiplier", 1f, "Multiplier spawnable chance Value [1.0 .. 3.0]");
			configValues.DeadlineDaysAmount = ((BaseUnityPlugin)Plugin.Instance).Config.Bind<int>(_sectionName ?? "", "DeadlineDaysAmount", 5, "Deadline Days Amount");
			return configValues;
		}
	}
}
namespace BrutalEvent.Enums
{
	public enum EventEnum
	{
		None,
		All,
		Chaos,
		Unfair,
		Landmine,
		Kleptomania,
		Arachnophobia,
		SecuritySystem,
		AllSnareFlea,
		BrackenAndCoil,
		BlobApocalypsis,
		WhoLetTheDogsOut,
		DidYouSeeHer,
		Tremors,
		GoToRent,
		Delivery,
		LetsFly,
		ReplaceItems
	}
}