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.Configuration;
using BepInEx.Logging;
using BrutalCompanyPlus.Api;
using BrutalCompanyPlus.Config;
using BrutalCompanyPlus.Events;
using BrutalCompanyPlus.Objects;
using BrutalCompanyPlus.Utils;
using DunGen;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("BrutalCompanyPlus")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A CUSTOMIZABLE hardcore mod that randomizes events ranging between insanity and normal.")]
[assembly: AssemblyFileVersion("4.0.0.0")]
[assembly: AssemblyInformationalVersion("4.0.0")]
[assembly: AssemblyProduct("BrutalCompanyPlus")]
[assembly: AssemblyTitle("BrutalCompanyPlus")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
	static <Module>()
	{
	}
}
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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BrutalCompanyPlus
{
	[BepInPlugin("BrutalCompanyPlus", "BrutalCompanyPlus", "4.0.0")]
	[BepInProcess("Lethal Company.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static GameObject BCNetworkManagerPrefab;

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			PluginConfig.Bind(this);
			EventRegistry.AutoRegister((BaseUnityPlugin)(object)this);
			BcpUtils.InitializeNetcode();
			InitializeBCNetworkManager();
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
			Logger.LogWarning((object)"BrutalCompanyPlus initialized...");
		}

		private static void InitializeBCNetworkManager()
		{
			Logger.LogWarning((object)"Initializing BCNetworkManager...");
			AssetBundle val = AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream("BrutalCompanyPlus.Assets.brutalcompanyplus"));
			BCNetworkManagerPrefab = val.LoadAsset<GameObject>("Assets/BCNetworkManager.prefab");
			BCNetworkManagerPrefab.AddComponent<BCNetworkManager>();
			val.Unload(false);
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "BrutalCompanyPlus";

		public const string PLUGIN_NAME = "BrutalCompanyPlus";

		public const string PLUGIN_VERSION = "4.0.0";
	}
}
namespace BrutalCompanyPlus.Utils
{
	public static class BcpUtils
	{
		internal static void InitializeNetcode()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array = methods;
				foreach (MethodInfo methodInfo in array)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (!customAttributes.IsEmpty())
					{
						Plugin.Logger.LogWarning((object)("Initializing RPCs for " + type.Name + "..."));
						methodInfo.Invoke(null, null);
					}
				}
			}
		}

		public static void AddCredits(this Terminal Terminal, int Amount)
		{
			Terminal.groupCredits += Amount;
			Terminal.SyncGroupCreditsServerRpc(Terminal.groupCredits, Terminal.numberOfItemsInDropship);
		}

		public static Vector3 GetNearbyLocation(Vector3 Location)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0012: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Random.insideUnitSphere * 10f;
			return Location + val;
		}

		public static GameObject FindObjectPrefab<T>(this SelectableLevel Level) where T : MonoBehaviour
		{
			SpawnableMapObject[] spawnableMapObjects = Level.spawnableMapObjects;
			foreach (SpawnableMapObject val in spawnableMapObjects)
			{
				if (val.IsObjectTypeOf<T>(out var _))
				{
					return val.prefabToSpawn;
				}
			}
			throw new Exception("Unable to find prefab of type " + typeof(T).Name + " in level " + ((Object)Level).name + ".");
		}

		public static bool IsObjectTypeOf<T>(this SpawnableMapObject MapObject, out T Component)
		{
			Component = MapObject.prefabToSpawn.GetComponentInChildren<T>();
			return Component != null;
		}

		public static bool IntInRange(this IntRange Range, int Value)
		{
			if (Value >= Range.Min)
			{
				return Value <= Range.Max;
			}
			return false;
		}

		public static bool IsEmpty<T>(this IEnumerable<T> Collection)
		{
			return !Collection.Any();
		}

		public static List<T> TakeIf<T>(this List<T> List, Func<T, bool> Predicate)
		{
			List<T> result = List.Where(Predicate).ToList();
			List.RemoveAll((T E) => Predicate(E));
			return result;
		}

		public static bool Random<T>(this List<T> List, out T Value)
		{
			if (List.IsEmpty())
			{
				Value = default(T);
				return false;
			}
			Value = List[Random.Range(0, List.Count)];
			return true;
		}

		public static bool Random<T>(this T[] Array, out T Value)
		{
			if (Array.IsEmpty())
			{
				Value = default(T);
				return false;
			}
			Value = Array[Random.Range(0, Array.Length)];
			return true;
		}

		public static bool Random<T>(this IEnumerable<T> Enumerable, out T Value)
		{
			return Enumerable.ToList().Random(out Value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ForEach<T, TResult>(this IEnumerable<T> Collection, Func<T, TResult> Action)
		{
			foreach (T item in Collection)
			{
				Action(item);
			}
		}
	}
	public static class ChatUtils
	{
		public static void Send(string Message, bool Clear = false)
		{
			if (Clear)
			{
				ChatUtils.Clear();
			}
			HUDManager.Instance.AddTextToChatOnServer(Message, -1);
		}

		public static void SendLocal(string Message, bool Clear = false)
		{
			if (Clear)
			{
				ChatUtils.Clear();
			}
			HUDManager.Instance.AddChatMessage(Message, "");
		}

		private static void Clear()
		{
			Send("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
		}

		internal static void NotifyError()
		{
			SendLocal("An error occurred in BrutalCompanyPlus. Check the console for more information.");
		}
	}
	public static class ConfigUtils
	{
		public static bool GetIfSet<T>(this ConfigEntry<T> Entry, out T Value) where T : notnull
		{
			T value = Entry.Value;
			if (value is int && (int)(object)/*isinst with value type is only supported in some contexts*/ == -1)
			{
				Value = default(T);
				return false;
			}
			Value = Entry.Value;
			return true;
		}

		internal static Dictionary<string, int> GetEnemyRarityValues(string LevelName)
		{
			string[] array = ((ConfigEntry<string>)(LevelName switch
			{
				"ExperimentationLevel" => PluginConfig.EnemyRarityValues.ExperimentationLevel, 
				"AssuranceLevel" => PluginConfig.EnemyRarityValues.AssuranceLevel, 
				"VowLevel" => PluginConfig.EnemyRarityValues.VowLevel, 
				"OffenseLevel" => PluginConfig.EnemyRarityValues.OffenseLevel, 
				"MarchLevel" => PluginConfig.EnemyRarityValues.MarchLevel, 
				"RendLevel" => PluginConfig.EnemyRarityValues.RendLevel, 
				"DineLevel" => PluginConfig.EnemyRarityValues.DineLevel, 
				"TitanLevel" => PluginConfig.EnemyRarityValues.TitanLevel, 
				_ => PluginConfig.EnemyRarityValues.CustomLevel, 
			})).Value.Split(',');
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			string[] array2 = array;
			foreach (string text in array2)
			{
				try
				{
					var (key, value) = ParseHelpers.ParseEnemyRarityEntry(text);
					dictionary.Add(key, value);
				}
				catch (ParseException arg)
				{
					Diagnostics.AddError($"Bad entry in enemy rarity values ({text}): {arg}");
				}
			}
			if (!dictionary.IsEmpty())
			{
				return dictionary;
			}
			Plugin.Logger.LogError((object)("Invalid enemy rarity values: " + PluginConfig.MoonHeat.HeatCurve.Value));
			return dictionary;
		}

		internal static (int, int, int, int) GetScrapValues(string LevelName)
		{
			string text = ((ConfigEntry<string>)(LevelName switch
			{
				"ExperimentationLevel" => PluginConfig.ScrapValues.ExperimentationLevel, 
				"AssuranceLevel" => PluginConfig.ScrapValues.AssuranceLevel, 
				"VowLevel" => PluginConfig.ScrapValues.VowLevel, 
				"OffenseLevel" => PluginConfig.ScrapValues.OffenseLevel, 
				"MarchLevel" => PluginConfig.ScrapValues.MarchLevel, 
				"RendLevel" => PluginConfig.ScrapValues.RendLevel, 
				"DineLevel" => PluginConfig.ScrapValues.DineLevel, 
				"TitanLevel" => PluginConfig.ScrapValues.TitanLevel, 
				_ => PluginConfig.ScrapValues.CustomLevel, 
			})).Value.Trim();
			if (text == "-1,-1,-1,-1")
			{
				Plugin.Logger.LogWarning((object)("Using default scrap values for " + LevelName));
				return (-1, -1, -1, -1);
			}
			try
			{
				return ParseHelpers.ParseScrapValues(text);
			}
			catch (ParseException arg)
			{
				Diagnostics.AddError($"Invalid scrap values ({text}): {arg}");
				return (-1, -1, -1, -1);
			}
		}

		internal static List<(int, int, LevelWeatherType)> GetMoonHeatCurve()
		{
			List<(int, int, LevelWeatherType)> list = new List<(int, int, LevelWeatherType)>();
			string[] array = PluginConfig.MoonHeat.HeatCurve.Value.Split(',');
			foreach (string text in array)
			{
				try
				{
					(int, int, LevelWeatherType) item = ParseHelpers.ParseHeatCurvePoint(text);
					list.Add(item);
				}
				catch (ParseException arg)
				{
					Diagnostics.AddError($"Bad point in moon heat curve ({text}): {arg}");
				}
			}
			if (!list.IsEmpty())
			{
				return list;
			}
			Plugin.Logger.LogError((object)("Invalid moon heat curve: " + PluginConfig.MoonHeat.HeatCurve.Value));
			Plugin.Logger.LogError((object)"Using fallback curve instead (0-100%: no weather)");
			list.Add((0, 101, (LevelWeatherType)(-1)));
			return list;
		}
	}
	internal static class Diagnostics
	{
		private static readonly List<string> Errors = new List<string>();

		internal static bool HasErrors => !Errors.IsEmpty();

		internal static void AddError(string Error)
		{
			Errors.Add(Error);
			Plugin.Logger.LogError((object)Error);
		}

		internal static string CollectErrors()
		{
			string result = string.Join("\n", Errors);
			Errors.Clear();
			return result;
		}
	}
	internal static class EnemyUtils
	{
		private static readonly Dictionary<string, EnemyType> InsideEnemyTypes = new Dictionary<string, EnemyType>();

		private static readonly Dictionary<string, EnemyType> OutsideEnemyTypes = new Dictionary<string, EnemyType>();

		internal static void SpawnInsideEnemy(RoundManager Instance, GameObject EnemyPrefab)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.allEnemyVents.Random(out var Value))
			{
				Vector3 position = Value.floorNode.position;
				Quaternion val = Quaternion.Euler(0f, Value.floorNode.eulerAngles.y, 0f);
				GameObject val2 = Object.Instantiate<GameObject>(EnemyPrefab, position, val);
				val2.GetComponentInChildren<NetworkObject>().Spawn(true);
				EnemyAI component = val2.GetComponent<EnemyAI>();
				if (component.enemyType.isOutsideEnemy)
				{
					component.enemyType = SetOutsideEnemy(component.enemyType, IsOutside: false);
					BCNetworkManager.Instance.SyncEnemyTypeClientRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)component), IsOutside: false);
				}
				Instance.SpawnedEnemies.Add(component);
			}
		}

		internal static void SpawnOutsideEnemy(RoundManager Instance, GameObject EnemyPrefab)
		{
			//IL_001b: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			if (GameObject.FindGameObjectsWithTag("OutsideAINode").Random(out var Value))
			{
				GameObject val = Object.Instantiate<GameObject>(EnemyPrefab, Value.transform.position, Quaternion.identity);
				val.GetComponentInChildren<NetworkObject>().Spawn(true);
				EnemyAI component = val.GetComponent<EnemyAI>();
				if (!component.enemyType.isOutsideEnemy)
				{
					component.enemyType = SetOutsideEnemy(component.enemyType, IsOutside: true);
					BCNetworkManager.Instance.SyncEnemyTypeClientRpc(NetworkBehaviourReference.op_Implicit((NetworkBehaviour)(object)component), IsOutside: true);
				}
				Instance.SpawnedEnemies.Add(component);
			}
		}

		internal static EnemyType SetOutsideEnemy(EnemyType OriginalType, bool IsOutside)
		{
			EnemyType value2;
			if (IsOutside)
			{
				if (OutsideEnemyTypes.TryGetValue(OriginalType.enemyName, out var value))
				{
					return value;
				}
			}
			else if (InsideEnemyTypes.TryGetValue(OriginalType.enemyName, out value2))
			{
				return value2;
			}
			EnemyType val = Object.Instantiate<EnemyType>(OriginalType);
			val.isOutsideEnemy = IsOutside;
			if (IsOutside)
			{
				OutsideEnemyTypes.Add(OriginalType.enemyName, val);
			}
			else
			{
				InsideEnemyTypes.Add(OriginalType.enemyName, val);
			}
			return val;
		}
	}
	internal static class LevelDefaults
	{
		internal static readonly Dictionary<string, Dictionary<string, int>> DefaultEnemyRarityValues = new Dictionary<string, Dictionary<string, int>>
		{
			{
				"ExperimentationLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 50 },
					{ "Bunker Spider", 75 },
					{ "Hoarding bug", 80 },
					{ "Flowerman", 30 },
					{ "Crawler", 15 },
					{ "Blob", 25 },
					{ "Girl", 2 },
					{ "Puffer", 10 },
					{ "Nutcracker", 15 },
					{ "Spring", 5 },
					{ "Jester", 1 },
					{ "Masked", 1 },
					{ "Lasso", 1 }
				}
			},
			{
				"AssuranceLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 50 },
					{ "Bunker Spider", 40 },
					{ "Hoarding bug", 50 },
					{ "Flowerman", 30 },
					{ "Crawler", 15 },
					{ "Blob", 25 },
					{ "Girl", 2 },
					{ "Puffer", 40 },
					{ "Nutcracker", 15 },
					{ "Spring", 25 },
					{ "Jester", 3 },
					{ "Masked", 3 },
					{ "Lasso", 1 }
				}
			},
			{
				"VowLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 50 },
					{ "Bunker Spider", 40 },
					{ "Hoarding bug", 50 },
					{ "Flowerman", 30 },
					{ "Crawler", 20 },
					{ "Blob", 25 },
					{ "Girl", 5 },
					{ "Puffer", 40 },
					{ "Nutcracker", 20 },
					{ "Spring", 40 },
					{ "Jester", 15 },
					{ "Masked", 10 },
					{ "Lasso", 0 }
				}
			},
			{
				"OffenseLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 50 },
					{ "Bunker Spider", 40 },
					{ "Hoarding bug", 50 },
					{ "Flowerman", 30 },
					{ "Crawler", 20 },
					{ "Blob", 25 },
					{ "Girl", 5 },
					{ "Puffer", 40 },
					{ "Nutcracker", 20 },
					{ "Spring", 40 },
					{ "Jester", 15 },
					{ "Masked", 10 },
					{ "Lasso", 0 }
				}
			},
			{
				"MarchLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 50 },
					{ "Bunker Spider", 40 },
					{ "Hoarding bug", 50 },
					{ "Flowerman", 30 },
					{ "Crawler", 20 },
					{ "Blob", 25 },
					{ "Girl", 10 },
					{ "Puffer", 40 },
					{ "Nutcracker", 20 },
					{ "Spring", 40 },
					{ "Jester", 15 },
					{ "Masked", 10 },
					{ "Lasso", 0 }
				}
			},
			{
				"RendLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 35 },
					{ "Bunker Spider", 25 },
					{ "Hoarding bug", 30 },
					{ "Flowerman", 56 },
					{ "Crawler", 50 },
					{ "Blob", 40 },
					{ "Girl", 25 },
					{ "Puffer", 40 },
					{ "Nutcracker", 30 },
					{ "Spring", 58 },
					{ "Jester", 40 },
					{ "Masked", 10 },
					{ "Lasso", 2 }
				}
			},
			{
				"DineLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 35 },
					{ "Bunker Spider", 25 },
					{ "Hoarding bug", 30 },
					{ "Flowerman", 56 },
					{ "Crawler", 50 },
					{ "Blob", 40 },
					{ "Girl", 25 },
					{ "Puffer", 40 },
					{ "Nutcracker", 30 },
					{ "Spring", 58 },
					{ "Jester", 40 },
					{ "Masked", 10 },
					{ "Lasso", 2 }
				}
			},
			{
				"TitanLevel",
				new Dictionary<string, int>
				{
					{ "Centipede", 35 },
					{ "Bunker Spider", 25 },
					{ "Hoarding bug", 30 },
					{ "Flowerman", 56 },
					{ "Crawler", 60 },
					{ "Blob", 40 },
					{ "Girl", 25 },
					{ "Puffer", 40 },
					{ "Nutcracker", 30 },
					{ "Spring", 58 },
					{ "Jester", 40 },
					{ "Masked", 10 },
					{ "Lasso", 2 }
				}
			},
			{
				"???_custom_???",
				new Dictionary<string, int>
				{
					{ "Centipede", 35 },
					{ "Bunker Spider", 25 },
					{ "Hoarding bug", 30 },
					{ "Flowerman", 56 },
					{ "Crawler", 60 },
					{ "Blob", 40 },
					{ "Girl", 25 },
					{ "Puffer", 40 },
					{ "Nutcracker", 30 },
					{ "Spring", 58 },
					{ "Jester", 40 },
					{ "Masked", 10 },
					{ "Lasso", 2 }
				}
			}
		};
	}
	public static class LevelNames
	{
		public const string CompanyBuilding = "CompanyBuildingLevel";

		public const string Experimentation = "ExperimentationLevel";

		public const string Assurance = "AssuranceLevel";

		public const string Vow = "VowLevel";

		public const string Offense = "OffenseLevel";

		public const string March = "MarchLevel";

		public const string Rend = "RendLevel";

		public const string Dine = "DineLevel";

		public const string Titan = "TitanLevel";

		internal const string Custom = "???_custom_???";

		public static readonly string[] All = new string[8] { "ExperimentationLevel", "AssuranceLevel", "VowLevel", "OffenseLevel", "MarchLevel", "RendLevel", "DineLevel", "TitanLevel" };

		internal static readonly string[] AllCustom = All.Concat(new string[1] { "???_custom_???" }).ToArray();

		public static bool IsCustom(string LevelName)
		{
			return !All.Contains(LevelName);
		}
	}
	internal static class ParseHelpers
	{
		private static readonly string RangeError = $"must be between {MoonHeatManager.MoonHeatRange.Min} and {MoonHeatManager.MoonHeatRange.Max}";

		internal static (int, int, LevelWeatherType) ParseHeatCurvePoint(string Point)
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			string[] array = Point.Split(':');
			if (array.Length != 3)
			{
				throw new ParseException("invalid format");
			}
			if (!int.TryParse(array[0], out var result))
			{
				throw new ParseException("invalid start value");
			}
			if (!MoonHeatManager.MoonHeatRange.IntInRange(result))
			{
				throw new ParseException("start value out of range, " + RangeError);
			}
			if (!int.TryParse(array[1], out var result2))
			{
				throw new ParseException("invalid end value");
			}
			if (!MoonHeatManager.MoonHeatRange.IntInRange(Math.Max(0, result2 - 1)))
			{
				throw new ParseException("end value out of range, " + RangeError);
			}
			if (!Enum.TryParse<LevelWeatherType>(array[2], out LevelWeatherType result3))
			{
				throw new ParseException("invalid weather type");
			}
			return (result, result2, result3);
		}

		internal static (int, int, int, int) ParseScrapValues(string Entries)
		{
			string[] array = Entries.Split(',');
			if (array.Length != 4)
			{
				throw new ParseException("invalid format");
			}
			if (!int.TryParse(array[0], out var result))
			{
				throw new ParseException("invalid minScrap value");
			}
			if (!int.TryParse(array[1], out var result2))
			{
				throw new ParseException("invalid maxScrap value");
			}
			if (!int.TryParse(array[2], out var result3))
			{
				throw new ParseException("invalid minTotalScrapValue value");
			}
			if (!int.TryParse(array[3], out var result4))
			{
				throw new ParseException("invalid maxTotalScrapValue value");
			}
			return (result, result2, result3, result4);
		}

		internal static (string, int) ParseEnemyRarityEntry(string Entry)
		{
			string[] array = Entry.Split(':');
			if (array.Length != 2)
			{
				throw new ParseException("invalid format");
			}
			string item;
			if (string.IsNullOrEmpty(item = array[0]))
			{
				throw new ParseException("invalid enemy name");
			}
			if (!int.TryParse(array[1], out var result))
			{
				throw new ParseException("invalid rarity value");
			}
			return (item, result);
		}
	}
	internal class ParseException : Exception
	{
		public ParseException(string Message)
			: base(Message)
		{
		}

		public override string ToString()
		{
			return Message;
		}
	}
	public static class PlayerUtils
	{
		public static IEnumerable<PlayerControllerB> AllPlayers => StartOfRound.Instance.allPlayerScripts.Where((PlayerControllerB Player) => Player.isPlayerControlled);

		public static IEnumerable<PlayerControllerB> AlivePlayers => AllPlayers.Where((PlayerControllerB Player) => !Player.isPlayerDead);

		public static IEnumerable<PlayerControllerB> OutsidePlayers => AlivePlayers.Where((PlayerControllerB Player) => !Player.isInHangarShipRoom && !Player.isInsideFactory);
	}
	public static class Singleton
	{
		public static Terminal Terminal => Object.FindObjectOfType<Terminal>();
	}
}
namespace BrutalCompanyPlus.Patches
{
	[HarmonyPatch]
	internal static class EnemyPatches
	{
		private const string Tag = "[EnemyPatches]";

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RoundManager), "BeginEnemySpawning")]
		private static void SpawnPendingEnemiesImmediately(ref RoundManager __instance)
		{
			if (EnemySpawnManager.PendingSpawns.IsEmpty())
			{
				return;
			}
			foreach (var (val, spawnInfo) in EnemySpawnManager.PendingSpawns.TakeIf(((EnemyType EnemyType, EnemySpawnManager.SpawnInfo SpawnInfo) si) => si.SpawnInfo.Immediate))
			{
				Plugin.Logger.LogInfo((object)string.Format("{0} Spawning {1} {2} (outside: {3}) enemies... (immediate)", "[EnemyPatches]", spawnInfo.Amount, val.enemyName, spawnInfo.Outside));
				for (int i = 0; i < spawnInfo.Amount; i++)
				{
					if (spawnInfo.Outside)
					{
						EnemyUtils.SpawnOutsideEnemy(__instance, val.enemyPrefab);
					}
					else
					{
						EnemyUtils.SpawnInsideEnemy(__instance, val.enemyPrefab);
					}
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RoundManager), "SpawnInsideEnemiesFromVentsIfReady")]
		private static void SpawnPendingEnemiesDelayed(ref RoundManager __instance)
		{
			if (EnemySpawnManager.PendingSpawns.IsEmpty() || !StartOfRound.Instance.allPlayerScripts.Any((PlayerControllerB player) => player.isInsideFactory))
			{
				return;
			}
			foreach (var (val, spawnInfo) in EnemySpawnManager.PendingSpawns.TakeIf(((EnemyType EnemyType, EnemySpawnManager.SpawnInfo SpawnInfo) si) => !si.SpawnInfo.Immediate))
			{
				Plugin.Logger.LogInfo((object)string.Format("{0} Spawning {1} {2} (outside: {3}) enemies... (delayed)", "[EnemyPatches]", spawnInfo.Amount, val.enemyName, spawnInfo.Outside));
				for (int i = 0; i < spawnInfo.Amount; i++)
				{
					if (spawnInfo.Outside)
					{
						EnemyUtils.SpawnOutsideEnemy(__instance, val.enemyPrefab);
					}
					else
					{
						EnemyUtils.SpawnInsideEnemy(__instance, val.enemyPrefab);
					}
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class LevelPatches
	{
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		private static void ModifyLevelsPatch(ref StartOfRound __instance)
		{
			if (!((NetworkBehaviour)__instance).IsHost)
			{
				return;
			}
			LevelManager.AddAllEnemiesToAllLevels(__instance.levels);
			SelectableLevel[] levels = __instance.levels;
			foreach (SelectableLevel val in levels)
			{
				if (!(((Object)val).name == "CompanyBuildingLevel"))
				{
					MoonHeatManager.InitializeFor(val);
					LevelManager.ApplyEnemyRarityValues(val);
					LevelManager.ApplyEnemySpawnChances(val);
					LevelManager.ApplyEnemySpawnRates(val);
					LevelManager.ApplyLevelProperties(val);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPriority(0)]
		[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
		private static void SelectLevelEventPatch(ref RoundManager __instance, ref SelectableLevel newLevel)
		{
			if (((NetworkBehaviour)__instance).IsHost)
			{
				if (((Object)newLevel).name == "CompanyBuildingLevel")
				{
					Plugin.Logger.LogWarning((object)"Landed at the Company Building, forcing no event...");
					ChatUtils.Send("<color=green>Welcome to the Company Building!</color>", Clear: true);
				}
				else
				{
					MoonHeatManager.AdjustHeatValues(newLevel);
					EventManager.StartEventServer(newLevel);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(RoundManager), "DespawnPropsAtEndOfRound")]
		private static void HandleLevelEventEndPatch(ref RoundManager __instance)
		{
			if (((NetworkBehaviour)__instance).IsHost)
			{
				EventManager.EndEventServer(__instance.currentLevel);
			}
		}
	}
	[HarmonyPatch]
	internal static class MoneyPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(TimeOfDay), "Awake")]
		private static void AdjustQuotaValues(ref TimeOfDay __instance)
		{
			Plugin.Logger.LogWarning((object)"Adjusting starting quota values...");
			if (PluginConfig.QuotaAdjustments.DeadlineDays.GetIfSet<int>(out var Value))
			{
				__instance.quotaVariables.deadlineDaysAmount = Value;
			}
			if (PluginConfig.QuotaAdjustments.StartingCredits.GetIfSet<int>(out Value))
			{
				__instance.quotaVariables.startingCredits = Value;
			}
			if (PluginConfig.QuotaAdjustments.StartingQuota.GetIfSet<int>(out Value))
			{
				__instance.quotaVariables.startingQuota = Value;
			}
			if (PluginConfig.QuotaAdjustments.BaseIncrease.GetIfSet<int>(out Value))
			{
				__instance.quotaVariables.baseIncrease = Value;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(RoundManager), "DetectElevatorIsRunning")]
		private static void CompensatePlayersPatch(ref RoundManager __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				if (StartOfRound.Instance.allPlayersDead)
				{
					ChatUtils.Send("<size=10><color=red>That was brutal! No compensation today :c</color></size>", Clear: true);
					return;
				}
				int value = PluginConfig.CreditsAdjustments.FreeMoneyAmount.Value;
				Singleton.Terminal.AddCredits(value);
				ChatUtils.Send("<size=10><color=green>You survived another day! Here's your compensation :)\n" + $"<color=orange>+{value} credits</color></size>", Clear: true);
			}
		}
	}
	[HarmonyPatch]
	internal static class NetcodePatches
	{
		[HarmonyPatch(typeof(GameNetworkManager), "Start")]
		[HarmonyPostfix]
		private static void InjectNetworkManager()
		{
			NetworkManager.Singleton.AddNetworkPrefab(Plugin.BCNetworkManagerPrefab);
		}

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPostfix]
		private static void SpawnNetworkManager()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer)
			{
				Object.Instantiate<GameObject>(Plugin.BCNetworkManagerPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>().Spawn(false);
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal static class PlayerPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void ShowDiagnosticsPatch(PlayerControllerB __instance)
		{
			__instance.movementAudio.priority = 127;
		}
	}
	[HarmonyPatch]
	internal class SharedEnemyAIPatches
	{
		private static Vector3 ShipLocation => StartOfRound.Instance.playerSpawnPositions[0].position;

		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(EnemyAI), "StartSearch")]
		private static void SpringManSearchFromShipPatch(ref EnemyAI __instance, ref Vector3 startOfSearch)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (__instance is SpringManAI && __instance.isOutside)
			{
				startOfSearch = BcpUtils.GetNearbyLocation(ShipLocation);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(FlowermanAI), "Start")]
		private static void FlowermanOutsideFavoritePositionPatch(ref FlowermanAI __instance)
		{
			//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)
			if (((EnemyAI)__instance).isOutside)
			{
				__instance.mainEntrancePosition = ShipLocation;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(BlobAI), "HitEnemy")]
		private static bool BlobDamageLagPatch(ref PlayerControllerB playerWhoHit)
		{
			return (Object)(object)playerWhoHit != (Object)null;
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal static class UIPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void ShowDiagnosticsPatch(MenuManager __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			if (!__instance.isInitScene && Diagnostics.HasErrors)
			{
				__instance.DisplayMenuNotification("[BrutalCompanyPlus]\nOne or more errors occurred during startup:\n" + Diagnostics.CollectErrors() + "\n\n", "[ Quit ]");
				((UnityEvent)__instance.menuNotification.GetComponentInChildren<Button>().onClick).AddListener(new UnityAction(__instance.ClickQuitButton));
			}
		}
	}
}
namespace BrutalCompanyPlus.Objects
{
	public class BCNetworkManager : NetworkBehaviour
	{
		private const string Tag = "[BCNetworkManager]";

		private const string DisconnectMessage = "BrutalCompanyPlus\nServer sent invalid enemy reference!\nThis is a bug, please report it!";

		public static BCNetworkManager Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Log("BCNetworkManager initialized!");
		}

		private void Update()
		{
			if (((NetworkBehaviour)this).IsServer && ((NetworkBehaviour)this).IsHost && EventManager.CurrentEvent != null)
			{
				EventManager.CurrentEvent.UpdateServer();
			}
		}

		[ClientRpc]
		public void SyncEnemyTypeClientRpc(NetworkBehaviourReference Reference, bool IsOutside)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2971397334u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref Reference, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref IsOutside, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2971397334u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || ((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				return;
			}
			Log($"Syncing enemy type (outside: {IsOutside})... (client)");
			EnemyAI val3 = default(EnemyAI);
			if (!((NetworkBehaviourReference)(ref Reference)).TryGet<EnemyAI>(ref val3, (NetworkManager)null))
			{
				Log("Bad enemy received from server! Disconnecting client to prevent further issues... (client)");
				GameNetworkManager.Instance.disconnectionReasonMessage = "BrutalCompanyPlus\nServer sent invalid enemy reference!\nThis is a bug, please report it!";
				GameNetworkManager.Instance.Disconnect();
				return;
			}
			val3.enemyType = EnemyUtils.SetOutsideEnemy(val3.enemyType, IsOutside);
			if (val3.path1 != null)
			{
				Plugin.Logger.LogWarning((object)("Received SyncEnemyType RPC for " + ((Object)val3).name + " too late, catching up..."));
				val3.isOutside = IsOutside;
				val3.allAINodes = GameObject.FindGameObjectsWithTag(IsOutside ? "OutsideAINode" : "AINode");
				if ((Object)(object)GameNetworkManager.Instance.localPlayerController != (Object)null)
				{
					val3.EnableEnemyMesh(!StartOfRound.Instance.hangarDoorsClosed || !GameNetworkManager.Instance.localPlayerController.isInHangarShipRoom, false);
				}
			}
		}

		[ClientRpc]
		public void StartEventClientRpc(int EventId, int LevelId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(554658467u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, EventId);
				BytePacker.WriteValueBitPacked(val2, LevelId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 554658467u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost) || ((NetworkBehaviour)this).IsServer || ((NetworkBehaviour)this).IsHost)
			{
				return;
			}
			Log($"Received start event request: eid = {EventId}, lid = {LevelId}");
			IEvent @event = EventRegistry.GetEvent(EventId);
			if (@event == null)
			{
				Log($"Bad event id {EventId} received from server.");
				return;
			}
			SelectableLevel val3 = StartOfRound.Instance.levels.ElementAtOrDefault(LevelId);
			if ((Object)(object)val3 == (Object)null)
			{
				Log($"Bad level id {LevelId} received from server.");
			}
			else
			{
				EventManager.StartEventClient(val3, @event);
			}
		}

		[ClientRpc]
		public void EndEventClientRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3012541483u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3012541483u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
				{
					Log("Received end event request... (client)");
					EventManager.EndEventClient(RoundManager.Instance.currentLevel);
				}
			}
		}

		[ClientRpc]
		public void SyncWeatherClientRpc(int LevelId, LevelWeatherType WeatherType)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(4219652153u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, LevelId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<LevelWeatherType>(ref WeatherType, default(ForEnums));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 4219652153u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				Log($"Syncing weather type {WeatherType} on level {LevelId}...");
				SelectableLevel val3 = StartOfRound.Instance.levels.ElementAtOrDefault(LevelId);
				if ((Object)(object)val3 == (Object)null)
				{
					Log($"Bad level id {LevelId} received from server.");
				}
				else
				{
					val3.currentWeather = WeatherType;
				}
			}
		}

		private static void Log(string Message)
		{
			Plugin.Logger.LogWarning((object)("[BCNetworkManager] " + Message));
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_BCNetworkManager()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2971397334u, new RpcReceiveHandler(__rpc_handler_2971397334));
			NetworkManager.__rpc_func_table.Add(554658467u, new RpcReceiveHandler(__rpc_handler_554658467));
			NetworkManager.__rpc_func_table.Add(3012541483u, new RpcReceiveHandler(__rpc_handler_3012541483));
			NetworkManager.__rpc_func_table.Add(4219652153u, new RpcReceiveHandler(__rpc_handler_4219652153));
		}

		private static void __rpc_handler_2971397334(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference reference = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref reference, default(ForNetworkSerializable));
				bool isOutside = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isOutside, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BCNetworkManager)(object)target).SyncEnemyTypeClientRpc(reference, isOutside);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_554658467(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int eventId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref eventId);
				int levelId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref levelId);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BCNetworkManager)(object)target).StartEventClientRpc(eventId, levelId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3012541483(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BCNetworkManager)(object)target).EndEventClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_4219652153(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int levelId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref levelId);
				LevelWeatherType weatherType = default(LevelWeatherType);
				((FastBufferReader)(ref reader)).ReadValueSafe<LevelWeatherType>(ref weatherType, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BCNetworkManager)(object)target).SyncWeatherClientRpc(levelId, weatherType);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BCNetworkManager";
		}
	}
	public static class EnemySpawnManager
	{
		public readonly struct SpawnInfo
		{
			public readonly int Amount;

			public readonly bool Outside;

			public readonly bool Immediate;

			public SpawnInfo(int Amount, bool Outside = false, bool Immediate = true)
			{
				this.Amount = Amount;
				this.Outside = Outside;
				this.Immediate = Immediate;
			}
		}

		internal static readonly List<(EnemyType EnemyType, SpawnInfo SpawnInfo)> PendingSpawns = new List<(EnemyType, SpawnInfo)>();

		public static void DraftEnemySpawn<T>(SpawnInfo Info) where T : EnemyAI
		{
			if (!LevelManager.TryGetEnemy<T>(out var EnemyType))
			{
				throw new ArgumentException("Failed to get EnemyType for " + typeof(T).Name + "!");
			}
			PendingSpawns.Add((EnemyType, Info));
		}

		public static void DraftEnemySpawn(EnemyType Type, SpawnInfo Info)
		{
			PendingSpawns.Add((Type, Info));
		}
	}
	public static class EventManager
	{
		internal static IEvent CurrentEvent;

		public static bool IsActive<T>() where T : IEvent
		{
			return CurrentEvent is T;
		}

		public static void StartEventServer(SelectableLevel Level)
		{
			if (CurrentEvent != null)
			{
				Plugin.Logger.LogError((object)"StartEventServer called twice, this shouldn't happen! (do you have LE installed?)");
				return;
			}
			IEvent @event = SelectRandomEvent(Level);
			if (@event != null)
			{
				Plugin.Logger.LogWarning((object)("Starting event " + @event.Name + "... (server)"));
				BCNetworkManager.Instance.StartEventClientRpc(@event.GetId(), Level.levelID);
				@event.ExecuteServer(Level);
				NotifyEventStarted(@event);
				CurrentEvent = @event;
			}
		}

		public static void EndEventServer(SelectableLevel Level)
		{
			if (CurrentEvent == null)
			{
				Plugin.Logger.LogError((object)"EndEventServer called without an active event, please report this!");
				ChatUtils.NotifyError();
				return;
			}
			Plugin.Logger.LogWarning((object)("Ending event " + CurrentEvent.Name + "... (server)"));
			BCNetworkManager.Instance.EndEventClientRpc();
			CurrentEvent.OnEnd(Level);
			LevelManager.UndoLevelPropertyChanges();
			CurrentEvent = null;
		}

		public static void StartEventClient(SelectableLevel Level, IEvent Event)
		{
			if (CurrentEvent != null)
			{
				Plugin.Logger.LogError((object)"StartEventClient called twice, this shouldn't happen! (did the server start an event twice?)");
				ChatUtils.NotifyError();
			}
			else
			{
				Plugin.Logger.LogWarning((object)("Starting event " + Event.Name + "... (client)"));
				Event.ExecuteClient(Level);
				CurrentEvent = Event;
			}
		}

		public static void EndEventClient(SelectableLevel Level)
		{
			if (CurrentEvent == null)
			{
				Plugin.Logger.LogError((object)"EndEventClient called without an active event, please report this!");
				ChatUtils.NotifyError();
			}
			else
			{
				Plugin.Logger.LogWarning((object)("Ending event " + CurrentEvent.Name + "... (client)"));
				CurrentEvent.OnEnd(Level);
				CurrentEvent = null;
			}
		}

		private static IEvent SelectRandomEvent(SelectableLevel Level)
		{
			int num = 0;
			while (true)
			{
				int num2 = Random.Range(0, 101);
				object obj;
				if (num2 <= PluginConfig.EventSettings.GlobalChance.Value)
				{
					obj = (PluginConfig.EventSettings.EqualChance.Value ? EventRegistry.GetRandomEventWithoutRarity() : EventRegistry.GetRandomEvent());
				}
				else
				{
					IEvent @event = EventRegistry.GetEvent<NoneEvent>();
					obj = @event;
				}
				IEvent event2 = (IEvent)obj;
				if (event2.CanRun(Level))
				{
					return event2;
				}
				if (++num > 20)
				{
					break;
				}
				Plugin.Logger.LogWarning((object)$"Event {event2.Name} cannot be ran, rerolling... (attempt {num} / {20})");
			}
			Plugin.Logger.LogWarning((object)$"Failed to select an event ({num} > {20}), forcing no event...");
			return EventRegistry.GetEvent<NoneEvent>();
		}

		private static void NotifyEventStarted(IEvent Event)
		{
			string text = Event.Positivity switch
			{
				EventPositivity.Positive => "green", 
				EventPositivity.Neutral => "white", 
				EventPositivity.Negative => "red", 
				EventPositivity.Golden => "orange", 
				_ => "white", 
			};
			ChatUtils.Send("<color=yellow>EVENT<color=white>:</color></color>\n<color=" + text + ">" + Event.Name + "</color>\n<color=white><size=70%>" + Event.Description + "</size></color>");
		}
	}
	internal static class LevelManager
	{
		private static readonly Dictionary<string, Action> UndoPropertyCallbacks = new Dictionary<string, Action>();

		public static List<SpawnableEnemyWithRarity> AllInsideEnemies;

		public static List<SpawnableEnemyWithRarity> AllOutsideEnemies;

		public static List<SpawnableEnemyWithRarity> AllDaytimeEnemies;

		public static IEnumerable<SpawnableEnemyWithRarity> AllEnemies => AllInsideEnemies.Concat(AllOutsideEnemies).Concat(AllDaytimeEnemies);

		public static bool TryGetEnemy<T>(out EnemyType EnemyType) where T : EnemyAI
		{
			EnemyType = AllEnemies.FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity Enemy) => (Object)(object)Enemy.enemyType.enemyPrefab.GetComponent<T>() != (Object)null))?.enemyType;
			return (Object)(object)EnemyType != (Object)null;
		}

		public static void ModifyLevelProperties(SelectableLevel Level, Action<SelectableLevel> Effect, params string[] Dependencies)
		{
			Dictionary<string, object> dictionary = new Dictionary<string, object>();
			foreach (string text in Dependencies)
			{
				FieldInfo field = ((object)Level).GetType().GetField(text);
				if (!dictionary.TryAdd(text, field.GetValue(Level)))
				{
					throw new Exception("Property '" + text + "' mentioned twice in dependencies array!");
				}
			}
			Effect(Level);
			foreach (string text2 in Dependencies)
			{
				FieldInfo property = ((object)Level).GetType().GetField(text2);
				object originalValue = dictionary[text2];
				object value = property.GetValue(Level);
				if (!originalValue.Equals(value) && !UndoPropertyCallbacks.TryAdd(text2, delegate
				{
					property.SetValue(Level, originalValue);
				}))
				{
					throw new Exception("Property '" + text2 + "' already contains an undo callback! Did you call ModifyLevelProperties twice on the same property?");
				}
			}
		}

		public static void SpawnMapObject(GameObject Prefab, Vector3 Position, Quaternion Rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Object.Instantiate<GameObject>(Prefab, Position, Rotation, RoundManager.Instance.mapPropsContainer.transform).GetComponent<NetworkObject>().Spawn(true);
		}

		public static T SpawnMapObject<T>(GameObject Prefab, Vector3 Position, Quaternion Rotation)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(Prefab, Position, Rotation, RoundManager.Instance.mapPropsContainer.transform);
			val.GetComponent<NetworkObject>().Spawn(true);
			return val.GetComponentInChildren<T>();
		}

		internal static void UndoLevelPropertyChanges()
		{
			Plugin.Logger.LogDebug((object)"Undoing level property changes... (server)");
			foreach (Action value in UndoPropertyCallbacks.Values)
			{
				value();
			}
			UndoPropertyCallbacks.Clear();
		}

		internal static void AddAllEnemiesToAllLevels(SelectableLevel[] Levels)
		{
			AllInsideEnemies = Levels.SelectMany((SelectableLevel Level) => Level.Enemies).SortEnemies();
			AllOutsideEnemies = Levels.SelectMany((SelectableLevel Level) => Level.OutsideEnemies).SortEnemies();
			AllDaytimeEnemies = Levels.SelectMany((SelectableLevel Level) => Level.DaytimeEnemies).SortEnemies();
			if (!PluginConfig.EnemyAdjustments.SpawnOnAllMoons.Value)
			{
				return;
			}
			foreach (SelectableLevel level in Levels)
			{
				level.Enemies.AddRange(AllInsideEnemies.Where((SpawnableEnemyWithRarity InsideEnemy) => level.Enemies.All((SpawnableEnemyWithRarity Enemy) => Enemy.enemyType.enemyName != InsideEnemy.enemyType.enemyName)));
			}
		}

		internal static void ApplyEnemyRarityValues(SelectableLevel Level)
		{
			if (!PluginConfig.EnemyRarityValues.Enabled.Value)
			{
				return;
			}
			Dictionary<string, int> enemyRarityValues = ConfigUtils.GetEnemyRarityValues(((Object)Level).name);
			string text = ((Object)Level).name;
			if (LevelNames.IsCustom(text))
			{
				text = "???_custom_???";
			}
			if (!LevelDefaults.DefaultEnemyRarityValues.TryGetValue(text, out var value))
			{
				Plugin.Logger.LogError((object)("No default rarity values found for level: " + ((Object)Level).name));
				return;
			}
			foreach (SpawnableEnemyWithRarity enemy in Level.Enemies)
			{
				string enemyName = enemy.enemyType.enemyName;
				if ((!enemyRarityValues.TryGetValue(enemyName, out var value2) || value2 == -1) && !value.TryGetValue(enemyName, out value2))
				{
					Plugin.Logger.LogError((object)("No default rarity value found for enemy: " + enemyName));
				}
				else
				{
					enemy.rarity = value2;
				}
			}
		}

		internal static void ApplyEnemySpawnChances(SelectableLevel Level)
		{
			MultiplyCurvePoints(ref Level.enemySpawnChanceThroughoutDay, 3, PositiveOnly: true);
			MultiplyCurvePoints(ref Level.outsideEnemySpawnChanceThroughDay, 3, PositiveOnly: true);
		}

		internal static void ApplyEnemySpawnRates(SelectableLevel Level)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: 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)
			//IL_00b6: Expected O, but got Unknown
			SpawnableMapObject[] spawnableMapObjects = Level.spawnableMapObjects;
			foreach (SpawnableMapObject val in spawnableMapObjects)
			{
				if (val.IsObjectTypeOf<Turret>(out var _) && PluginConfig.MapHazards.TurretSpawnRate.GetIfSet<int>(out var Value))
				{
					val.numberToSpawn = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0f, 0f),
						new Keyframe(1f, (float)Value)
					});
				}
				if (val.IsObjectTypeOf<Landmine>(out var _) && PluginConfig.MapHazards.LandmineSpawnRate.GetIfSet<int>(out Value))
				{
					val.numberToSpawn = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0f, 0f),
						new Keyframe(1f, (float)Value)
					});
				}
			}
		}

		internal static void ApplyLevelProperties(SelectableLevel Level)
		{
			var (newValue, newValue2, newValue3, newValue4) = ConfigUtils.GetScrapValues(((Object)Level).name);
			ApplyIfSet(ref Level.minScrap, newValue);
			ApplyIfSet(ref Level.maxScrap, newValue2);
			ApplyIfSet(ref Level.minTotalScrapValue, newValue3);
			ApplyIfSet(ref Level.maxTotalScrapValue, newValue4);
			Level.maxEnemyPowerCount += 150;
			Level.maxOutsideEnemyPowerCount += 10;
			Level.maxDaytimeEnemyPowerCount += 150;
		}

		private static void ApplyIfSet(ref int Value, int NewValue)
		{
			if (NewValue != -1)
			{
				Value = NewValue;
			}
		}

		private static void MultiplyCurvePoints(ref AnimationCurve Curve, int Multiplier, bool PositiveOnly = false)
		{
			Keyframe[] keys = Curve.keys;
			for (int i = 0; i < keys.Length; i++)
			{
				if (!PositiveOnly || !(((Keyframe)(ref keys[i])).value < 0f))
				{
					ref Keyframe reference = ref keys[i];
					((Keyframe)(ref reference)).value = ((Keyframe)(ref reference)).value * (float)Multiplier;
				}
			}
			Curve.keys = keys;
		}

		private static List<SpawnableEnemyWithRarity> SortEnemies(this IEnumerable<SpawnableEnemyWithRarity> Enemies)
		{
			return (from Enemy in Enemies
				orderby Enemy.rarity descending
				group Enemy by Enemy.enemyType.enemyName into Group
				select Group.First()).ToList();
		}
	}
	public static class MoonHeatManager
	{
		public static readonly IntRange MoonHeatRange = new IntRange(0, 100);

		private static readonly Dictionary<SelectableLevel, float> LevelHeatValues = new Dictionary<SelectableLevel, float>();

		public static void InitializeFor(SelectableLevel Level)
		{
			LevelHeatValues.TryAdd(Level, 0f);
		}

		public static void ResetHeatValues()
		{
			foreach (SelectableLevel item in LevelHeatValues.Keys.ToList())
			{
				LevelHeatValues[item] = 0f;
			}
		}

		public static void AdjustHeatValues(SelectableLevel CurrentLevel)
		{
			float heat = IncreaseHeatValueOf(CurrentLevel);
			foreach (SelectableLevel item in LevelHeatValues.Keys.ToList())
			{
				if (!((Object)(object)CurrentLevel == (Object)(object)item))
				{
					DecreaseHeatValueOf(item);
				}
			}
			NotifyPlayersAndSetWeather(CurrentLevel, heat);
		}

		private static float IncreaseHeatValueOf(SelectableLevel Level)
		{
			if (!LevelHeatValues.TryGetValue(Level, out var value))
			{
				return 0f;
			}
			LevelHeatValues[Level] = Mathf.Clamp(value + PluginConfig.MoonHeat.IncreaseRate.Value, (float)MoonHeatRange.Min, (float)MoonHeatRange.Max);
			return value;
		}

		private static void DecreaseHeatValueOf(SelectableLevel Level)
		{
			if (LevelHeatValues.TryGetValue(Level, out var value))
			{
				LevelHeatValues[Level] = Mathf.Clamp(value - PluginConfig.MoonHeat.DecreaseRate.Value, (float)MoonHeatRange.Min, (float)MoonHeatRange.Max);
			}
		}

		private static void NotifyPlayersAndSetWeather(SelectableLevel CurrentLevel, float Heat)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_0084: Expected I4, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected I4, but got Unknown
			ChatUtils.Send("<color=orange>MOON IS AT " + Heat + "% HEAT</color>", Clear: true);
			foreach (var (num, num2, val) in ConfigUtils.GetMoonHeatCurve())
			{
				if (!(Heat < (float)num) && !(Heat >= (float)num2))
				{
					BCNetworkManager.Instance.SyncWeatherClientRpc(CurrentLevel.levelID, val);
					NotifyChat((val - 1) switch
					{
						0 => "blue", 
						2 => "purple", 
						3 => "yellow", 
						1 => "orange", 
						4 => "red", 
						_ => "white", 
					}, (val - 1) switch
					{
						0 => "Heat is rising and caused it to rain...", 
						2 => "Heat is rising, causing a layer of fog...", 
						3 => "Moon is getting hot, causing a flood...", 
						1 => "Extreme heat is causing a dangerous weather...", 
						4 => "Moon is at max heat, causing hostile creatures to roam it...", 
						_ => "Heat is rising...", 
					});
					break;
				}
			}
		}

		private static void NotifyChat(string Color, string Title)
		{
			ChatUtils.Send("<size=11><color=" + Color + ">" + Title + "</color>\n<color=white>Visit other moons to decrease the heat!</color></size>");
		}
	}
}
namespace BrutalCompanyPlus.Events
{
	[UsedImplicitly]
	[HarmonyPatch]
	public class BlobEvolutionEvent : IEvent
	{
		private const float NormalSpeed = 3.8f;

		private const float OpenDoorSpeedMultiplier = 1.5f;

		public string Name => "They are EVOLVING?!";

		public string Description => "Here I was, thinking that Pokémon was the only game with evolutions.";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			SetBlobEnemyTag();
			EnemySpawnManager.DraftEnemySpawn<BlobAI>(new EnemySpawnManager.SpawnInfo(3));
			EnemySpawnManager.DraftEnemySpawn<BlobAI>(new EnemySpawnManager.SpawnInfo(1, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
			SetBlobEnemyTag();
		}

		public void OnEnd(SelectableLevel Level)
		{
			SetBlobEnemyTag(Unset: true);
		}

		private static void SetBlobEnemyTag(bool Unset = false)
		{
			if (LevelManager.TryGetEnemy<BlobAI>(out EnemyType EnemyType))
			{
				string tag = (Unset ? "Untagged" : "Enemy");
				Transform val = EnemyType.enemyPrefab.transform.Find("Armature");
				((Component)val).gameObject.tag = tag;
				EnemyAICollisionDetect[] componentsInChildren = ((Component)val).GetComponentsInChildren<EnemyAICollisionDetect>();
				foreach (EnemyAICollisionDetect val2 in componentsInChildren)
				{
					((Component)val2).gameObject.tag = tag;
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(BlobAI), "Update")]
		private static void EnemyAIPatch(ref BlobAI __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && EventManager.IsActive<BlobEvolutionEvent>())
			{
				((EnemyAI)__instance).agent.speed = 3.8f;
				((EnemyAI)__instance).openDoorSpeedMultiplier = 1.5f;
			}
		}
	}
	[UsedImplicitly]
	public class DeliveryEvent : IEvent
	{
		private const int MinItems = 2;

		private const int MaxItems = 9;

		public string Name => "ICE SCREAM!!!";

		public string Description => "Mommy, the ice cream truck is here!";

		public EventPositivity Positivity => EventPositivity.Positive;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			int num = Singleton.Terminal.buyableItemsList.Length;
			int num2 = Random.Range(2, 9);
			for (int i = 0; i < num2; i++)
			{
				Singleton.Terminal.orderedItemsFromTerminal.Add(Random.Range(0, num));
			}
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class FaceHuggersEvent : IEvent
	{
		public string Name => "Bring a shovel!";

		public string Description => "They just want a hug...";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<CentipedeAI>(new EnemySpawnManager.SpawnInfo(15, Outside: false, Immediate: false));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class GuardsEvent : IEvent
	{
		public string Name => "They guard this place!";

		public string Description => "Better not get kicked out again...";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<NutcrackerEnemyAI>(new EnemySpawnManager.SpawnInfo(4, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class HideAndSeekEvent : IEvent
	{
		public string Name => "Hide and Seek";

		public string Description => "She's gonna find you...";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<DressGirlAI>(new EnemySpawnManager.SpawnInfo(5));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class HoarderTownEvent : IEvent
	{
		public string Name => "Hoarder Town";

		public string Description => "Come on, those are mine!";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<HoarderBugAI>(new EnemySpawnManager.SpawnInfo(6));
			EnemySpawnManager.DraftEnemySpawn<HoarderBugAI>(new EnemySpawnManager.SpawnInfo(3, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class HungerGamesEvent : IEvent
	{
		private PlayerControllerB _currentTarget;

		private bool _playerKilled;

		public string Name => "The Hunger Games";

		public string Description => "May the odds be ever in your favor.";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public bool CanRun(SelectableLevel Level)
		{
			return StartOfRound.Instance.connectedPlayersAmount > 0;
		}

		public void ExecuteServer(SelectableLevel Level)
		{
			PickNewTarget();
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		public void UpdateServer()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			if (!_playerKilled && !((Object)(object)_currentTarget == (Object)null))
			{
				if (_currentTarget.isPlayerDead && !StartOfRound.Instance.allPlayersDead)
				{
					PickNewTarget();
				}
				if (_currentTarget.isInsideFactory)
				{
					_playerKilled = true;
					_currentTarget.DamagePlayerFromOtherClientServerRpc(_currentTarget.health, default(Vector3), (int)_currentTarget.playerClientId);
					ChatUtils.Send("<color=purple>" + _currentTarget.playerUsername + "</color> <color=orange>volunteered as Tribute!</color>");
				}
			}
		}

		public void OnEnd(SelectableLevel Level)
		{
			_currentTarget = null;
			_playerKilled = false;
		}

		private void PickNewTarget()
		{
			if (PlayerUtils.AlivePlayers.Random(out _currentTarget))
			{
				this.Log("New target chosen: " + _currentTarget.playerUsername);
			}
		}
	}
	[UsedImplicitly]
	[HarmonyPatch]
	public class InstaJesterEvent : IEvent
	{
		private const float MinTimer = 1f;

		private const float MaxTimer = 5f;

		public string Name => "Pop goes the.. HOLY FUC-";

		public string Description => "Lord have mercy on your soul.";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<JesterAI>(new EnemySpawnManager.SpawnInfo(2));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(JesterAI), "SetJesterInitialValues")]
		private static void EnemyAIPatch(ref JesterAI __instance)
		{
			if (EventManager.IsActive<InstaJesterEvent>())
			{
				__instance.popUpTimer = Random.Range(1f, 5f);
			}
		}
	}
	[UsedImplicitly]
	public class NoneEvent : IEvent
	{
		public string Name => "Nothing happened today!";

		public string Description => "Just another Tuesday.";

		public EventPositivity Positivity => EventPositivity.Positive;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	[HarmonyPatch]
	public class OutsideTheBoxEvent : IEvent
	{
		public string Name => "Outside the box!";

		public string Description => "Creepy...";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<JesterAI>(new EnemySpawnManager.SpawnInfo(2, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		private static bool HookResetFlag(PlayerControllerB player, EnemyAI Instance)
		{
			if (EventManager.IsActive<OutsideTheBoxEvent>() && Instance.isOutside)
			{
				return !player.isInsideFactory;
			}
			return player.isInsideFactory;
		}

		[HarmonyTranspiler]
		[HarmonyPatch(typeof(JesterAI), "Update")]
		private static IEnumerable<CodeInstruction> EnemyAIPatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerControllerB), "isInsideFactory");
			MethodInfo methodInfo = AccessTools.Method(typeof(OutsideTheBoxEvent), "HookResetFlag", (Type[])null, (Type[])null);
			bool flag = false;
			List<CodeInstruction> list = instructions.ToList();
			for (int i = 1; i < list.Count; i++)
			{
				if (CodeInstructionExtensions.LoadsField(list[i - 1], fieldInfo, false) && !(list[i].opcode != OpCodes.Brfalse))
				{
					list[i - 1] = new CodeInstruction(OpCodes.Ldarg_0, (object)null);
					list.Insert(i, new CodeInstruction(OpCodes.Call, (object)methodInfo));
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				Diagnostics.AddError("Failed to patch JesterAI.Update()! (event: OutsideTheBoxEvent, ver: 4.0.0)");
			}
			return list.AsEnumerable();
		}
	}
	[UsedImplicitly]
	public class ResetHeatEvent : IEvent
	{
		public string Name => "All moon heat has been reset!";

		public string Description => "Seems like Pluto just passed by.";

		public EventPositivity Positivity => EventPositivity.Positive;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			MoonHeatManager.ResetHeatValues();
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class ShadowRealmEvent : IEvent
	{
		public string Name => "The shadows are roaming";

		public string Description => "Did you hear that?";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<FlowermanAI>(new EnemySpawnManager.SpawnInfo(6, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class ShipTurretEvent : IEvent
	{
		private static readonly Vector3 TurretPosition = new Vector3(3.87f, 0.84f, -14.23f);

		private GameObject _prefab;

		private GameObject _turret;

		private bool _shouldSpawn;

		private bool _spawned;

		public string Name => "When did we get this installed?!";

		public string Description => "I'm innocent, I swear!";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			if (_prefab == null)
			{
				_prefab = Level.FindObjectPrefab<Turret>();
			}
			_shouldSpawn = true;
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		public void UpdateServer()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (_shouldSpawn)
			{
				_shouldSpawn = false;
				_spawned = true;
				_turret = Object.Instantiate<GameObject>(_prefab, TurretPosition, Quaternion.identity);
				_turret.transform.forward = new Vector3(1f, 0f, 0f);
				_turret.GetComponent<NetworkObject>().Spawn(true);
			}
			else if (_spawned && StartOfRound.Instance.shipIsLeaving)
			{
				_spawned = false;
				_turret.GetComponent<NetworkObject>().Despawn(true);
				ChatUtils.Send("<color=green>Turret removal procedure complete.</color>");
			}
		}

		public void OnEnd(SelectableLevel Level)
		{
			_shouldSpawn = false;
			_spawned = false;
		}
	}
	[UsedImplicitly]
	public class SpringbreakEvent : IEvent
	{
		public string Name => "Springbreak";

		public string Description => "Don't get a concussion!";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<SpringManAI>(new EnemySpawnManager.SpawnInfo(3, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class SurfaceExplosionEvent : IEvent
	{
		private static readonly Vector3 MineDistance = new Vector3(9.33f, 5.2f, 1021f);

		private const int StartSpawnInterval = 10;

		private const int MinSpawnInterval = 1;

		private const int MaxSpawnInterval = 4;

		private GameObject _prefab;

		private float _spawnTimer;

		public string Name => "The surface is explosive!";

		public string Description => "EXPLOSION!!!";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			_spawnTimer = 10f;
			if (_prefab == null)
			{
				_prefab = Level.FindObjectPrefab<Landmine>();
			}
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		public void UpdateServer()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (StartOfRound.Instance.allPlayersDead)
			{
				return;
			}
			if (_spawnTimer >= 0f)
			{
				_spawnTimer -= Time.deltaTime;
				return;
			}
			_spawnTimer = Random.Range(1, 4);
			if (PlayerUtils.OutsidePlayers.Random(out var Value))
			{
				Vector3 position = ((Component)Value).transform.position;
				if (Vector3.Distance(position, MineDistance) < 1f)
				{
					_spawnTimer = -1f;
				}
				else
				{
					LevelManager.SpawnMapObject<Landmine>(_prefab, position, Quaternion.identity).TriggerMineOnLocalClientByExiting();
				}
			}
		}
	}
	[UsedImplicitly]
	public class TheBeastsInsideEvent : IEvent
	{
		public string Name => "The Beasts Inside";

		public string Description => "Ssshhhh...";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<MouthDogAI>(new EnemySpawnManager.SpawnInfo(((Object)Level).name switch
			{
				"ExperimentationLevel" => 2, 
				"AssuranceLevel" => 2, 
				"VowLevel" => 2, 
				"OffenseLevel" => 3, 
				"MarchLevel" => 3, 
				"RendLevel" => 4, 
				"DineLevel" => 4, 
				"TitanLevel" => 6, 
				_ => 4, 
			}));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	[HarmonyPatch]
	public class TheRumblingEvent : IEvent
	{
		private const float NormalSpeed = 6f;

		public string Name => "The Rumbling";

		public string Description => "Fix the Barricades!";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Uncommon;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<ForestGiantAI>(new EnemySpawnManager.SpawnInfo(((Object)Level).name switch
			{
				"ExperimentationLevel" => 6, 
				"AssuranceLevel" => 8, 
				"VowLevel" => 8, 
				"OffenseLevel" => 8, 
				"MarchLevel" => 8, 
				"RendLevel" => 10, 
				"DineLevel" => 10, 
				"TitanLevel" => 8, 
				_ => 8, 
			}, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(ForestGiantAI), "Update")]
		private static void EnemyAIPatch(ref ForestGiantAI __instance)
		{
			if (((NetworkBehaviour)__instance).IsOwner && EventManager.IsActive<TheRumblingEvent>() && ((EnemyAI)__instance).currentBehaviourStateIndex == 1 && !__instance.inEatingPlayerAnimation)
			{
				((EnemyAI)__instance).agent.speed = 6f;
			}
		}
	}
	[UsedImplicitly]
	public class TheyAreShyEvent : IEvent
	{
		public string Name => "Don't look... away?";

		public string Description => "Instructions unclear.";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.Rare;

		public void ExecuteServer(SelectableLevel Level)
		{
			EnemySpawnManager.DraftEnemySpawn<SpringManAI>(new EnemySpawnManager.SpawnInfo(3));
			EnemySpawnManager.DraftEnemySpawn<FlowermanAI>(new EnemySpawnManager.SpawnInfo(3));
			EnemySpawnManager.DraftEnemySpawn<SpringManAI>(new EnemySpawnManager.SpawnInfo(2, Outside: true));
			EnemySpawnManager.DraftEnemySpawn<FlowermanAI>(new EnemySpawnManager.SpawnInfo(3, Outside: true));
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
	[UsedImplicitly]
	public class UnfairCompanyEvent : IEvent
	{
		private const int OutsideEnemyCount = 3;

		public string Name => "Unfair Company";

		public string Description => "Sometimes, life just ain't fair.";

		public EventPositivity Positivity => EventPositivity.Negative;

		public EventRarity DefaultRarity => EventRarity.VeryRare;

		public void ExecuteServer(SelectableLevel Level)
		{
			for (int i = 0; i < 3; i++)
			{
				if (LevelManager.AllOutsideEnemies.Random(out var Value))
				{
					EnemySpawnManager.DraftEnemySpawn(Value.enemyType, new EnemySpawnManager.SpawnInfo(1, Outside: true));
				}
			}
			LevelManager.ModifyLevelProperties(Level, delegate(SelectableLevel Level)
			{
				//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_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Expected O, but got Unknown
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				Level.outsideEnemySpawnChanceThroughDay = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0f, 999f),
					new Keyframe(1f, 999f)
				});
				Level.enemySpawnChanceThroughoutDay = new AnimationCurve((Keyframe[])(object)new Keyframe[2]
				{
					new Keyframe(0f, 500f),
					new Keyframe(1f, 500f)
				});
			}, "outsideEnemySpawnChanceThroughDay", "enemySpawnChanceThroughoutDay");
		}

		public void ExecuteClient(SelectableLevel Level)
		{
		}
	}
}
namespace BrutalCompanyPlus.Config
{
	[AttributeUsage(AttributeTargets.Class)]
	public class ConfigCategory : Attribute
	{
		public readonly string Name;

		public ConfigCategory(string Name)
		{
			this.Name = Name;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class SharedDescription : Attribute
	{
		public readonly string Template;

		public SharedDescription(string Template)
		{
			this.Template = Template;
		}
	}
	[AttributeUsage(AttributeTargets.Property)]
	public class Configuration : Attribute
	{
		public readonly object DefaultValue;

		internal readonly bool ExcludeFromShared;

		public string Name { get; internal set; }

		public ConfigDescription Description { get; internal set; }

		private Configuration(string Name, ConfigDescription Description, object DefaultValue, bool ExcludeFromShared)
		{
			this.Name = Name;
			this.Description = Description;
			this.DefaultValue = DefaultValue;
			this.ExcludeFromShared = ExcludeFromShared;
		}

		public Configuration(string Description, object DefaultValue, bool ExcludeFromShared = false)
			: this(null, new ConfigDescription(Description, (AcceptableValueBase)null, Array.Empty<object>()), DefaultValue, ExcludeFromShared)
		{
		}//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_0015: Expected O, but got Unknown


		public Configuration(string Description, int DefaultValue, int MinValue, int MaxValue, bool ExcludeFromShared = false)
			: this(null, new ConfigDescription(Description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(MinValue, MaxValue), Array.Empty<object>()), DefaultValue, ExcludeFromShared)
		{
		}//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Expected O, but got Unknown


		public override string ToString()
		{
			return $"(name: {Name}, description: {Description.Description}, default: {DefaultValue})";
		}
	}
	public static class ConfigLoader
	{
		public static void Bind(Plugin Plugin)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				if (!type.TryGetAttribute<ConfigCategory>(out var Attribute))
				{
					continue;
				}
				Plugin.Logger.LogDebug((object)("Binding config for " + type.Name + "..."));
				PropertyInfo[] properties = type.GetProperties(BindingFlags.Static | BindingFlags.Public);
				Plugin.Logger.LogDebug((object)$"Found {properties.Length} properties...");
				PropertyInfo[] array = properties;
				foreach (PropertyInfo propertyInfo in array)
				{
					if (!propertyInfo.TryGetAttribute<Configuration>(out var Attribute2))
					{
						continue;
					}
					Plugin.Logger.LogDebug((object)("Binding config for " + propertyInfo.Name + "..."));
					if (string.IsNullOrEmpty(Attribute2.Name))
					{
						Attribute2.Name = propertyInfo.Name;
					}
					if (!Attribute2.ExcludeFromShared && type.TryGetAttribute<SharedDescription>(out var Attribute3))
					{
						Attribute2.Description = new ConfigDescription(Attribute3.Template.Replace("{}", Attribute2.Description.Description), Attribute2.Description.AcceptableValues, Attribute2.Description.Tags);
					}
					if (propertyInfo.TryGetEntryType(out var Type))
					{
						object obj = Convert.ChangeType(Attribute2.DefaultValue, Type);
						Plugin.Logger.LogDebug((object)$"Binding config for {type.Name}/{propertyInfo.Name}: {Attribute2}");
						object value = typeof(ConfigFile).GetMethods(BindingFlags.Instance | BindingFlags.Public).FirstOrDefault((MethodInfo M) => M.Name == "Bind" && M.GetParameters().Length == 4 && M.GetParameters()[3].ParameterType == typeof(ConfigDescription)).MakeGenericMethod(Type)
							.Invoke(((BaseUnityPlugin)Plugin).Config, new object[4] { Attribute.Name, Attribute2.Name, obj, Attribute2.Description });
						propertyInfo.SetValue(null, value);
					}
				}
			}
		}

		private static bool TryGetAttribute<T>(this MemberInfo Member, out T Attribute) where T : Attribute
		{
			object[] customAttributes = Member.GetCustomAttributes(typeof(T), inherit: false);
			if (customAttributes.IsEmpty())
			{
				Attribute = null;
				return false;
			}
			Attribute = (T)customAttributes[0];
			return true;
		}

		private static bool TryGetEntryType(this PropertyInfo Info, out Type Type)
		{
			if (!Info.PropertyType.IsGenericType || Info.PropertyType.GetGenericTypeDefinition() != typeof(ConfigEntry<>))
			{
				Type = null;
				return false;
			}
			Type[] genericArguments = Info.PropertyType.GetGenericArguments();
			if (genericArguments.Length != 1)
			{
				Type = null;
				return false;
			}
			Type = genericArguments[0];
			return true;
		}
	}
	internal static class EventConfig
	{
		private const string Category = "Event Rarities";

		internal static void RegisterWith(BaseUnityPlugin FromPlugin, ref List<IEvent> Events)
		{
			foreach (IEvent Event in Events)
			{
				try
				{
					string text = Event.Name.Replace("'", "");
					EventRegistry.EventRarityValues[Event] = FromPlugin.Config.Bind<EventRarity>("Event Rarities", text, Event.DefaultRarity, Event.Description).Value;
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)ex.ToString());
					string text2 = ((FromPlugin.Info.Metadata.GUID != "BrutalCompanyPlus") ? (" from " + FromPlugin.Info.Metadata.Name) : "");
					Diagnostics.AddError("Failed to register event \"" + Event.Name + "\"" + text2 + "! See console for details.");
					EventRegistry.EventRarityValues[Event] = Event.DefaultRarity;
				}
			}
		}
	}
	internal static class PluginConfig
	{
		[ConfigCategory("Custom Scrap Values")]
		[SharedDescription("Define min/max scrap pieces and min/max total scrap value for {} (for vanilla, use: -1,-1,-1,-1)")]
		public static class ScrapValues
		{
			public const string DefaultValues = "-1,-1,-1,-1";

			[Configuration("Experimentation", "6,25,400,1500", false)]
			public static ConfigEntry<string> ExperimentationLevel { get; set; }

			[Configuration("Assurance", "10,25,600,2500", false)]
			public static ConfigEntry<string> AssuranceLevel { get; set; }

			[Configuration("Vow", "12,35,600,2500", false)]
			public static ConfigEntry<string> VowLevel { get; set; }

			[Configuration("Offense", "15,35,800,3500", false)]
			public static ConfigEntry<string> OffenseLevel { get; set; }

			[Configuration("March", "15,35,800,3500", false)]
			public static ConfigEntry<string> MarchLevel { get; set; }

			[Configuration("Rend", "20,60,1500,5000", false)]
			public static ConfigEntry<string> RendLevel { get; set; }

			[Configuration("Dine", "20,60,1500,5000", false)]
			public static ConfigEntry<string> DineLevel { get; set; }

			[Configuration("Titan", "20,60,2000,6000", false)]
			public static ConfigEntry<string> TitanLevel { get; set; }

			[Configuration("any custom levels", "20,60,2000,6000", false)]
			public static ConfigEntry<string> CustomLevel { get; set; }
		}

		[ConfigCategory("Moon Heat")]
		public static class MoonHeat
		{
			[Configuration("Rate at which the moon heat increases by when landing back on the same planet", 20f, false)]
			public static ConfigEntry<float> IncreaseRate { get; set; }

			[Configuration("Rate at which the moon heat decreases by when not visiting the planet", 10f, false)]
			public static ConfigEntry<float> DecreaseRate { get; set; }

			[Configuration("Defines how moon heat affects the weather (format: `start:end:type`, start is inclusive and end is exclusive)", "20:40:Rainy,40:60:Foggy,60:80:Flooded,80:100:Stormy,100:101:Eclipsed", false)]
			public static ConfigEntry<string> HeatCurve { get; set; }
		}

		[ConfigCategory("Map Hazard Adjustments")]
		public static class MapHazards
		{
			[Configuration("Amount of turrets that should be spawned (for vanilla, use: -1)", 8, false)]
			public static ConfigEntry<int> TurretSpawnRate { get; set; }

			[Configuration("Amount of landmines that should be spawned (for vanilla, use: -1)", 30, false)]
			public static ConfigEntry<int> LandmineSpawnRate { get; set; }
		}

		[ConfigCategory("Enemy Rarity Values")]
		[SharedDescription("Define custom enemy rarity values for {} (no spawn: 0, max chance: 100, BCP default: -1)")]
		public static class EnemyRarityValues
		{
			private const string DefaultRarity = "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1";

			[Configuration("Set this to `false` if you want vanilla spawning behavior.", true, true)]
			public static ConfigEntry<bool> Enabled { get; set; }

			[Configuration("Experimentation", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> ExperimentationLevel { get; set; }

			[Configuration("Assurance", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> AssuranceLevel { get; set; }

			[Configuration("Vow", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> VowLevel { get; set; }

			[Configuration("Offense", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> OffenseLevel { get; set; }

			[Configuration("March", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> MarchLevel { get; set; }

			[Configuration("Rend", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> RendLevel { get; set; }

			[Configuration("Dine", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> DineLevel { get; set; }

			[Configuration("Titan", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> TitanLevel { get; set; }

			[Configuration("any custom levels", "Centipede:-1,Bunker Spider:-1,Hoarding bug:-1,Flowerman:-1,Crawler:-1,Blob:-1,Girl:-1,Puffer:-1,Nutcracker:-1,Spring:-1,Jester:-1,Masked:-1,Lasso:-1", false)]
			public static ConfigEntry<string> CustomLevel { get; set; }
		}

		[ConfigCategory("Credits-related Adjustments")]
		public static class CreditsAdjustments
		{
			[Configuration("Amount of money to give when a player leaves a moon alive (to disable, use: -1)", 150, false)]
			public static ConfigEntry<int> FreeMoneyAmount { get; set; }
		}

		[ConfigCategory("Enemy-related Adjustments")]
		public static class EnemyAdjustments
		{
			[Configuration("Whether all enemies should be nominated for spawning on all moons (vanilla: false)", true, false)]
			public static ConfigEntry<bool> SpawnOnAllMoons { get; set; }
		}

		[ConfigCategory("Quota-related Adjustments")]
		public static class QuotaAdjustments
		{
			[Configuration("Days available before deadline (for vanilla, use: -1)", 4, false)]
			public static ConfigEntry<int> DeadlineDays { get; set; }

			[Configuration("Amount of credits everyone gets at the start of a new session (for vanilla, use: -1)", 200, false)]
			public static ConfigEntry<int> StartingCredits { get; set; }

			[Configuration("Quota you begin with at the start of a new session (for vanilla, use: -1)", 400, false)]
			public static ConfigEntry<int> StartingQuota { get; set; }

			[Configuration("Rate at which the quota increases by when it's met (for vanilla, use: -1)", 275, false)]
			public static ConfigEntry<int> BaseIncrease { get; set; }
		}

		[ConfigCategory("Event Settings")]
		public static class EventSettings
		{
			[Configuration("Chance between 0 and 100 for an event to occur (this is separate from event rarity and no events may still occur even if the chance is met!)", 100, 0, 100, false)]
			public static ConfigEntry<int> GlobalChance { get; set; }

			[Configuration("Whether all events have equal chance to happen (disables event rarity altogether!)", false, false)]
			public static ConfigEntry<bool> EqualChance { get; set; }
		}

		internal static void Bind(Plugin Plugin)
		{
			ConfigLoader.Bind(Plugin);
			Validate();
		}

		private static void Validate()
		{
			LevelNames.AllCustom.ForEach(ConfigUtils.GetEnemyRarityValues);
			LevelNames.AllCustom.ForEach(ConfigUtils.GetScrapValues);
			ConfigUtils.GetMoonHeatCurve();
		}
	}
}
namespace BrutalCompanyPlus.Api
{
	public static class EventRegistry
	{
		private static readonly List<IEvent> RegisteredEvents = new List<IEvent>();

		internal static readonly Dictionary<IEvent, EventRarity> EventRarityValues = new Dictionary<IEvent, EventRarity>();

		[UsedImplicitly]
		public static void RegisterEvents(BaseUnityPlugin FromPlugin, List<IEvent> Events)
		{
			EventConfig.RegisterWith(FromPlugin, ref Events);
			RegisteredEvents.AddRange(Events);
			Plugin.Logger.LogWarning((object)$"Registered {Events.Count} events from {FromPlugin.Info.Metadata.Name}:");
			foreach (IEvent Event in Events)
			{
				Plugin.Logger.LogWarning((object)$"Registered event: {Event.Name} (rarity: {Event.GetRarity()}, description: {Event.Description})");
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void AutoRegister(BaseUnityPlugin FromPlugin)
		{
			IEnumerable<IEvent> source = from type in Assembly.GetCallingAssembly().GetTypes()
				where type.IsClass && typeof(IEvent).IsAssignableFrom(type)
				select (IEvent)Activator.CreateInstance(type);
			RegisterEvents(FromPlugin, source.ToList());
		}

		public static T GetEvent<T>() where T : IEvent
		{
			return (T)(RegisteredEvents.FirstOrDefault((IEvent Event) => Event is T) ?? ((object)default(T)));
		}

		public static IEvent GetEvent(int EventId)
		{
			return RegisteredEvents.ElementAtOrDefault(EventId);
		}

		private static EventRarity GetRarity(this IEvent Event)
		{
			return EventRarityValues[Event];
		}

		public static int GetId(this IEvent Event)
		{
			return RegisteredEvents.IndexOf(Event);
		}

		public static bool IsActive(this IEvent Event)
		{
			return EventManager.CurrentEvent == Event;
		}

		internal static IEvent GetRandomEvent()
		{
			int num = RegisteredEvents.Sum((IEvent Event) => (int)Event.GetRarity());
			int num2 = Random.Range(0, num);
			foreach (IEvent registeredEvent in RegisteredEvents)
			{
				num2 = (int)(num2 - registeredEvent.GetRarity());
				if (num2 <= 0)
				{
					return registeredEvent;
				}
			}
			Plugin.Logger.LogFatal((object)$"Failed to get random event! (totalRarity: {num}, random: {num2})");
			return GetEvent<NoneEvent>();
		}

		internal static IEvent GetRandomEventWithoutRarity()
		{
			if (RegisteredEvents.Where((IEvent Event) => Event.GetRarity() != EventRarity.Disabled).Random(out var Value))
			{
				return Value;
			}
			Plugin.Logger.LogFatal((object)"Failed to get random event! (without rarity)");
			return GetEvent<NoneEvent>();
		}
	}
	public interface IEvent
	{
		string Name { get; }

		string Description { get; }

		EventPositivity Positivity { get; }

		EventRarity DefaultRarity { get; }

		bool CanRun([UsedImplicitly] SelectableLevel Level)
		{
			return true;
		}

		void ExecuteServer([UsedImplicitly] SelectableLevel Level);

		void ExecuteClient([UsedImplicitly] SelectableLevel Level);

		void UpdateServer()
		{
		}

		void OnEnd([UsedImplicitly] SelectableLevel Level)
		{
		}
	}
	public enum EventPositivity
	{
		Positive,
		Neutral,
		Negative,
		Golden
	}
	public enum EventRarity
	{
		[Obsolete("For configuration purposes only. Do not use.")]
		Disabled = 0,
		Common = 100,
		Uncommon = 85,
		Rare = 60,
		VeryRare = 40,
		UltraRare = 20
	}
	public static class EventExtensions
	{
		public static void Log(this IEvent Event, string Message)
		{
			Plugin.Logger.LogInfo((object)("[Event (" + Event.Name + ")] " + Message));
		}
	}
}