using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MissionUtils;
using REPOLib.Modules;
using UnityEngine;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoWebListener
{
	public class Dictionaries
	{
		public static readonly Dictionary<string, string> ItemPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "Item Cart Medium", "items/Item Cart Medium" },
			{ "Item Cart Small", "items/Item Cart Small" },
			{ "Item Drone Battery", "items/Item Drone Battery" },
			{ "Item Drone Feather", "items/Item Drone Feather" },
			{ "Item Drone Indestructible", "items/Item Drone Indestructible" },
			{ "Item Drone Torque", "items/Item Drone Torque" },
			{ "Item Drone Zero Gravity", "items/Item Drone Zero Gravity" },
			{ "Item Extraction Tracker", "items/Item Extraction Tracker" },
			{ "Item Grenade Duct Taped", "items/Item Grenade Duct Taped" },
			{ "Item Grenade Explosive", "items/Item Grenade Explosive" },
			{ "Item Grenade Human", "items/Item Grenade Human" },
			{ "Item Grenade Shockwave", "items/Item Grenade Shockwave" },
			{ "Item Grenade Stun", "items/Item Grenade Stun" },
			{ "Item Gun Handgun", "items/Item Gun Handgun" },
			{ "Item Gun Shotgun", "items/Item Gun Shotgun" },
			{ "Item Gun Tranq", "items/Item Gun Tranq" },
			{ "Item Health Pack Large", "items/Item Health Pack Large" },
			{ "Item Health Pack Medium", "items/Item Health Pack Medium" },
			{ "Item Health Pack Small", "items/Item Health Pack Small" },
			{ "Item Melee Baseball Bat", "items/Item Melee Baseball Bat" },
			{ "Item Melee Frying Pan", "items/Item Melee Frying Pan" },
			{ "Item Melee Inflatable Hammer", "items/Item Melee Inflatable Hammer" },
			{ "Item Melee Sledge Hammer", "items/Item Melee Sledge Hammer" },
			{ "Item Melee Sword", "items/Item Melee Sword" },
			{ "Item Mine Explosive", "items/Item Mine Explosive" },
			{ "Item Mine Shockwave", "items/Item Mine Shockwave" },
			{ "Mine Stun", "items/Item Mine Stun" },
			{ "Item Orb Zero Gravity", "items/Item Orb Zero Gravity" },
			{ "Item Power Crystal", "items/Item Power Crystal" },
			{ "Item Rubber Duck", "items/Item Rubber Duck" },
			{ "Item Upgrade Map Player Count", "items/Item Upgrade Map Player Count" },
			{ "Item Upgrade Player Energy", "items/Item Upgrade Player Energy" },
			{ "Item Upgrade Player Extra Jump", "items/Item Upgrade Player Extra Jump" },
			{ "Item Upgrade Player Grab Range", "items/Item Upgrade Player Grab Range" },
			{ "Item Upgrade Player Grab Strength", "items/Item Upgrade Player Grab Strength" },
			{ "Item Upgrade Player Grab Throw", "items/Item Upgrade Player Grab Throw" },
			{ "Item Upgrade Player Health", "items/Item Upgrade Player Health" },
			{ "Item Upgrade Player Sprint Speed", "items/Item Upgrade Player Sprint Speed" },
			{ "Item Upgrade Player Tumble Launch", "items/Item Upgrade Player Tumble Launch" },
			{ "Item Valuable Tracker", "items/Item Valuable Tracker" }
		};

		public static readonly Dictionary<string, string> ValuablePaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "Valuable Diamond", "valuables/01 tiny/Valuable Diamond" },
			{ "Valuable Emerald Bracelet", "valuables/01 tiny/Valuable Emerald Bracelet" },
			{ "Valuable Goblet", "valuables/01 tiny/Valuable Goblet" },
			{ "Valuable Ocarina", "valuables/01 tiny/Valuable Ocarina" },
			{ "Valuable Pocket Watch", "valuables/01 tiny/Valuable Pocket Watch" },
			{ "Valuable Uranium Mug", "valuables/01 tiny/Valuable Uranium Mug" },
			{ "Valuable Arctic Bonsai", "valuables/02 small/Valuable Arctic Bonsai" },
			{ "Valuable Arctic HDD", "valuables/02 small/Valuable Arctic HDD" },
			{ "Valuable Chomp Book", "valuables/02 small/Valuable Chomp Book" },
			{ "Valuable Crown", "valuables/02 small/Valuable Crown" },
			{ "Valuable Doll", "valuables/02 small/Valuable Doll" },
			{ "Valuable Frog", "valuables/02 small/Valuable Frog" },
			{ "Valuable Gem Box", "valuables/02 small/Valuable Gem Box" },
			{ "Valuable Globe", "valuables/02 small/Valuable Globe" },
			{ "Valuable Love Potion", "valuables/02 small/Valuable Love Potion" },
			{ "Valuable Money", "valuables/02 small/Valable Money" },
			{ "Valuable Music Box", "valuables/02 small/Valueable Music Box" },
			{ "Valuable Toy Monkey", "valuables/02 small/Vauble Toy Monkey" },
			{ "Valuable Uranium Plate", "valuables/02 small/Vauble Uranium Plate" },
			{ "Valuable Vase Small", "valuables/02 small/Valuable Vase Small" },
			{ "Valuable Arctic 3D Printer", "valuables/03 medium/Valuable Arctic 3D Printer" },
			{ "Valuable Arctic Laptop", "valuables/03 medium/Valuable Arctic Laptop" },
			{ "Valuable Arctic Propane Tank", "valuables/03 medium/Valuable Arctic Propane Tank" },
			{ "Valuable Arctic Sample Six Pack", "valuables/03 medium/Valuable Arctic Sample Six Pack" },
			{ "Valuable Arctic Sample", "valuables/03 medium/Valable Bottle" },
			{ "Valuable Bottle", "valuables/03 medium/Valable Bottle" },
			{ "Valuable Clown", "valuables/03 medium/Valueable Clown" },
			{ "Valuable Computer", "valuables/03 medium/Vauble Computer" },
			{ "Valuable Fan", "valuables/03 medium/Vauble Fan" },
			{ "Valuable Gramophone", "valuables/03 medium/Vauble Gramophone" },
			{ "Valuable Marble Table", "valuables/03 medium/Vauble Marble Table" },
			{ "Valuable Radio", "valuables/03 medium/Vauble Radio" },
			{ "Valuable Ship In Bottle", "valuables/03 medium/Vauble Ship in a bottle" },
			{ "Valuable Trophy", "valuables/03 medium/Vauble Trophy" },
			{ "Valuable Vase", "valuables/03 medium/Vauble Vase" },
			{ "Valuable Wizard Goblin Head", "valuables/03 medium/Vauble Wizard Goblin Head" },
			{ "Valuable Wizard Power Crystal", "valuables/03 medium/Vauble Wizard Power Crystal" },
			{ "Valuable Wizard Time Glass", "valuables/03 medium/Vauble Wizard Time Glass" },
			{ "Valuable Arctic Barrel", "valuables/04 big/Valuable Arctic Barrel" },
			{ "Valuable Arctic Big Sample", "valuables/04 big/Valuable Arctic Big Sample" },
			{ "Valuable Arctic Creature Leg", "valuables/04 big/Valuable Arctic Creature Leg" },
			{ "Valuable Arctic Flamethrower", "valuables/04 big/Valuable Arctic Flamethrower" },
			{ "Valuable Arctic Guitar", "valuables/04 big/Valuable Arctic Guitar" },
			{ "Valuable Arctic Sample Cooler", "valuables/04 big/Valuable Arctic Sample Cooler" },
			{ "Valuable Diamond Display", "valuables/04 big/Vauble Diamond Display" },
			{ "Valuable Ice Saw", "valuables/04 big/Vauble Ice Saw" },
			{ "Valuable Scream Doll", "valuables/04 big/Vauble Scream Doll" },
			{ "Valuable Television", "valuables/04 big/Vauble Television" },
			{ "Valuable Vase Big", "valuables/04 big/Vauble Vase Big" },
			{ "Valuable Wizard Cube Of Knowledge", "valuables/04 big/Vauble Wizard Cube of Knowledge" },
			{ "Valuable Wizard Master Potion", "valuables/04 big/Vauble Wizard Master Potion" },
			{ "Valuable Animal Crate", "valuables/05 wide/Vauble Animal Crate" },
			{ "Valuable Arctic Ice Block", "valuables/05 wide/Vauble Arctic Ice Block" },
			{ "Valuable Dinosaur", "valuables/05 wide/Vauble Dinosaur" },
			{ "Valuable Piano", "valuables/05 wide/Vauble Piano" },
			{ "Valuable Wizard Griffin Statue", "valuables/05 wide/Vauble Wizard Griffin Statue" },
			{ "Valuable Arctic Science Station", "valuables/06 tall/Vauble Arctic Science Station" },
			{ "Valuable Harp", "valuables/06 tall/Vauble Harp" },
			{ "Valuable Painting", "valuables/06 tall/Vauble Painting" },
			{ "Valuable Wizard Dumgolfs Staff", "valuables/06 tall/Vauble Wizard Dumgolfs Staff" },
			{ "Valuable Wizard Sword", "valuables/06 tall/Vauble Wizard Sword" },
			{ "Valuable Arctic Server Rack", "valuables/07 very tall/Vauble Arctic Server Rack" },
			{ "Valuable Golden Statue", "valuables/07 very tall/Valuable Golden Statue" },
			{ "Valuable Grandfather Clock", "valuables/07 very tall/Valuable Grandfather Clock" },
			{ "Valuable Wizard Broom", "valuables/07 very tall/Valuable Wizard Broom" }
		};

		public static readonly Dictionary<string, string> EnemyPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
		{
			{ "Beamer", "Beamer" },
			{ "Duck", "Apex Predator" },
			{ "Robe", "Robe" },
			{ "Bowtie", "Bowtie" },
			{ "Floater", "Floater" },
			{ "Gnome", "Gnome" },
			{ "Hunter", "Hunter" },
			{ "Tumbler", "Chef" },
			{ "Thin Man", "Shadow Child" },
			{ "Slow Mouth", "Spewer" },
			{ "Upscream", "Upscream" },
			{ "Hidden", "Hidden" },
			{ "Bang", "Banger" },
			{ "Head", "Headman" },
			{ "Runner", "Reaper" },
			{ "Slow Walker", "Trudge" }
		};
	}
	internal class Events
	{
		public class EAction
		{
			public string Name { get; set; }

			public List<string> TeaseMessages { get; set; }

			public bool IsForAll { get; set; }

			public PlayerAvatar Victim { get; set; } = null;


			public EType Type { get; set; } = EType.BAD;


			public bool IsForOnlyDeadPlayers { get; set; } = false;


			public bool IsForOnlyAlivePlayers { get; set; } = false;


			public Func<PlayerAvatar?, string[]> Action { get; set; }

			public EAction(string name, List<string> teaseMessages, bool isForAll, Func<PlayerAvatar?, string[]> action, bool isForOnlyDeadPlayers = false, bool isForOnlyAlivePlayers = false)
			{
				Name = name;
				TeaseMessages = teaseMessages;
				IsForAll = isForAll;
				Action = action;
				IsForOnlyDeadPlayers = isForOnlyDeadPlayers;
				IsForOnlyAlivePlayers = isForOnlyAlivePlayers;
			}

			public string[] Invoke(PlayerAvatar player = null)
			{
				if (IsForAll)
				{
					return Action(null);
				}
				if ((Object)(object)player == (Object)null)
				{
					return new string[1] { "Error: Player is null." };
				}
				Victim = player;
				return Action(player);
			}
		}

		public enum EType
		{
			BAD,
			GOOD
		}

		public class Event
		{
			public EAction Action { get; set; }

			public string ChatterMessage { get; set; }

			public string Chatter { get; set; }

			public Event(EAction action, string chatterMessage, string chatter)
			{
				Action = action;
				ChatterMessage = chatterMessage;
				Chatter = chatter;
			}

			public static Event Generate(string chatter)
			{
				EType type = (EType)PencilUtils.Randomizer.Next(0, Enum.GetValues(typeof(EType)).Length);
				return Generate(chatter, type);
			}

			public static Event Generate(string chatter, EType type)
			{
				EAction eAction = ((type == EType.BAD) ? PossibleBadActions[PencilUtils.Randomizer.Next(PossibleBadActions.Count)] : PossibleGoodActions[PencilUtils.Randomizer.Next(PossibleGoodActions.Count)]);
				eAction.Type = type;
				string chatterMessage = chatter + ", you rolled a " + eAction.Name + " event! It has been added to the queue.";
				return new Event(eAction, chatterMessage, chatter);
			}

			public string GenerateTeaseMessage(string template, string[] args, PlayerAvatar? victim = null)
			{
				string text = template;
				text = text.Replace("%chatter%", Chatter);
				text = text.Replace("%victim%", victim.playerName);
				foreach (string text2 in args)
				{
					text = text.Replace("%" + args.ToList().IndexOf(text2) + "%", text2);
				}
				return text;
			}

			public string GenerateTeaseMessage(string template, string[] args)
			{
				string text = template;
				text = text.Replace("%chatter%", Chatter);
				foreach (string text2 in args)
				{
					text = text.Replace("%" + args.ToList().IndexOf(text2) + "%", text2);
				}
				return text;
			}

			public string Execute(PlayerAvatar player)
			{
				if (Action.IsForAll)
				{
					return "Error occurred: Action is for all players, but a specific player was provided.";
				}
				string[] args = Action.Invoke(player);
				string template = Action.TeaseMessages[PencilUtils.Randomizer.Next(Action.TeaseMessages.Count)];
				return GenerateTeaseMessage(template, args, player);
			}

			public string Execute()
			{
				if (!Action.IsForAll)
				{
					return "Error occurred: Action is for a specific player, but no player was provided.";
				}
				string[] args = Action.Invoke();
				string template = Action.TeaseMessages[PencilUtils.Randomizer.Next(Action.TeaseMessages.Count)];
				return GenerateTeaseMessage(template, args);
			}

			public override string ToString()
			{
				return string.Format("Event: {0} ({1}), Chatter: {2}, ChatterMessage: {3}", Action.Name, Action.IsForAll ? "All" : ((string)(object)Action.Victim), Chatter, ChatterMessage);
			}
		}

		public static List<EAction> PossibleBadActions = new List<EAction>();

		public static List<EAction> PossibleGoodActions = new List<EAction>();

		public static Queue<Event> EventQueue = new Queue<Event>();

		public static void Init()
		{
			if (PencilUtils.PencilConfig.BadEventDamageSpecific)
			{
				PossibleBadActions.Add(new EAction("Deal Damage", new List<string> { "<b>%chatter%</b> slaps <b>%victim%</b> across the face for <b>-%0%</b> HP!", "<b>%chatter%</b> throws a rock at <b>%victim%</b> for <b>-%0%</b> HP!", "<b>%victim%</b> couldn't avoid <b>%chatter%</b>'s Ford F150 and took <b>-%0%</b> HP!", "<b>%chatter%</b> wanted to play catch with <b>%victim%</b>, but threw the ball too hard and hit them for <b>-%0%</b> HP!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					int num6 = PencilUtils.Randomizer.Next(PencilUtils.PencilConfig.BadEventDamageMinAmount, PencilUtils.PencilConfig.BadEventDamageMaxAmount);
					int num7 = num6;
					if (!PencilUtils.PencilConfig.BadEventDamageCanKill && player.playerHealth.health - num6 < 1)
					{
						num6 = ((player.playerHealth.health > 1) ? (player.playerHealth.health - 1) : 0);
					}
					player.playerHealth.HurtOther(num6, ((Component)player.playerHealth).transform.position, false, -1);
					return new string[1] { num7.ToString() };
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.BadEventDamageAll)
			{
				PossibleBadActions.Add(new EAction("Deal Damage to All", new List<string> { "<b>%chatter%</b> threw a grenade and hurt everyone, with <b>%0%</b> getting hurt the most for <b>-%1%</b> HP!", "<b>%chatter%</b> bombed the whole facility, with <b>%0%</b> getting hurt the most for <b>-%1%</b> HP!", "Everyone lost a lot of health because of <b>%chatter%</b>, but <b>%0%</b> lost the most with <b>-%1%</b> HP!" }, isForAll: true, delegate
				{
					//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
					PlayerAvatar val3 = null;
					int num4 = 0;
					foreach (PlayerAvatar alivePlayer in PencilUtils.GetAlivePlayers())
					{
						if (!Object.op_Implicit((Object)(object)val3))
						{
							val3 = alivePlayer;
						}
						int num5 = PencilUtils.Randomizer.Next(PencilUtils.PencilConfig.BadEventDamageMinAmount, PencilUtils.PencilConfig.BadEventDamageMaxAmount);
						if (num5 > num4)
						{
							num4 = num5;
							val3 = alivePlayer;
						}
						if (!PencilUtils.PencilConfig.BadEventDamageCanKill && alivePlayer.playerHealth.health - num5 < 1)
						{
							num5 = ((alivePlayer.playerHealth.health > 1) ? (alivePlayer.playerHealth.health - 1) : 0);
						}
						alivePlayer.playerHealth.HurtOther(num5, ((Component)alivePlayer.playerHealth).transform.position, false, -1);
					}
					return ((Object)(object)val3 == (Object)null) ? new string[2]
					{
						"???",
						num4.ToString()
					} : new string[2]
					{
						val3.playerName,
						num4.ToString()
					};
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.BadEventSpawnRandomEnemy)
			{
				PossibleBadActions.Add(new EAction("Spawn Random Enemy", new List<string> { "<b>%chatter%</b> summoned a <b>%0%</b> to attack <b>%victim%</b>!", "<b>%chatter%</b> called for help and a <b>%0%</b> appeared!", "<b>%chatter%</b> told a <b>%0%</b> that <b>%victim%</b> said something bad their mom!", "<b>%chatter%</b> threw a rock at a <b>%0%</b> and it thought <b>%victim%</b> did it!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					//IL_0070: 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)
					//IL_0085: 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_008f: Unknown result type (might be due to invalid IL or missing references)
					string text3 = RepoWebListener.AllowedEnemies.Keys.ElementAt(PencilUtils.Randomizer.Next(RepoWebListener.AllowedEnemies.Count));
					EnemySetup val2 = RepoWebListener.AllowedEnemies[text3];
					if ((Object)(object)val2 == (Object)null)
					{
						RepoWebListener.Logger.LogError((object)("Enemy " + text3 + " not found. Cannot spawn."));
						return new string[1] { "???" };
					}
					Enemies.SpawnEnemy(val2, ((Component)player).transform.position + ((Component)player).transform.up * 0.2f, Quaternion.identity, false);
					return new string[1] { Dictionaries.EnemyPaths[text3] };
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventHealAll)
			{
				PossibleGoodActions.Add(new EAction("Heal All", new List<string> { "<b>%chatter%</b> healed everyone a bit, but <b>%0%</b> got healed the most with +<b>%1%</b> HP!", "<b>%chatter%</b> used a splash potion, healing everyone with <b>%0%</b> getting healed the most! (+<b>%1%</b> HP)", "<b>%chatter%</b> used a health pack on <b>%0%</b> for +<b>%1%</b> HP, but it had a ripple effect on everyone else!" }, isForAll: true, delegate
				{
					PlayerAvatar val = null;
					int num2 = 0;
					foreach (PlayerAvatar alivePlayer2 in PencilUtils.GetAlivePlayers())
					{
						if (!Object.op_Implicit((Object)(object)val))
						{
							val = alivePlayer2;
						}
						int num3 = PencilUtils.Randomizer.Next(PencilUtils.PencilConfig.GoodEventHealMinAmount, PencilUtils.PencilConfig.GoodEventHealMaxAmount);
						if (num3 > num2)
						{
							num2 = num3;
							val = alivePlayer2;
						}
						alivePlayer2.playerHealth.HealOther(num3, true);
					}
					return ((Object)(object)val == (Object)null) ? new string[2]
					{
						"???",
						num2.ToString()
					} : new string[2]
					{
						val.playerName,
						num2.ToString()
					};
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventHealSpecific)
			{
				PossibleGoodActions.Add(new EAction("Heal Specific", new List<string> { "<b>%chatter%</b> healed <b>%victim%</b> for +<b>%0%</b> HP!", "<b>%chatter%</b> used a health pack on <b>%victim%</b> for +<b>%0%</b> HP!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					int num = PencilUtils.Randomizer.Next(PencilUtils.PencilConfig.GoodEventHealMinAmount, PencilUtils.PencilConfig.GoodEventHealMaxAmount);
					player.playerHealth.HealOther(num, true);
					return new string[1] { num.ToString() };
				}));
			}
			if (PencilUtils.PencilConfig.GoodEventSpawnRandomItem && PencilUtils.GetAllowedItems().Count > 0)
			{
				PossibleGoodActions.Add(new EAction("Spawn Random Item", new List<string> { "<b>%chatter%</b> bought a <b>%0%</b> for <b>%victim%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)player == (Object)null)
					{
						RepoWebListener.Logger.LogError((object)"Player is null. Cannot spawn item.");
						return new string[1] { "???" };
					}
					string text2 = RepoWebListener.AllowedItems.Keys.ElementAt(PencilUtils.Randomizer.Next(RepoWebListener.AllowedItems.Count));
					Item itemThatContainsName = Items.GetItemThatContainsName(text2);
					if ((Object)(object)itemThatContainsName == (Object)null)
					{
						RepoWebListener.Logger.LogError((object)$"Item {text2} not found out of {Items.GetItems().Count} items. Cannot spawn.");
						ManualLogSource logger2 = RepoWebListener.Logger;
						Item? obj2 = Items.GetItems().FirstOrDefault();
						logger2.LogError((object)("First item: " + ((obj2 != null) ? ((Object)obj2).name : null)));
						return new string[1] { "???" };
					}
					Items.SpawnItem(itemThatContainsName, ((Component)player).transform.position + ((Component)player).transform.up * 0.2f, Quaternion.identity);
					return new string[1] { text2.Replace("Item ", "") };
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventSpawnRandomValuable && PencilUtils.GetAllowedValuables().Count > 0)
			{
				PossibleGoodActions.Add(new EAction("Spawn Random Valuable", new List<string> { "<b>%chatter%</b> found a <b>%0%</b> and put it next to <b>%victim%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
					//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)player == (Object)null)
					{
						RepoWebListener.Logger.LogError((object)"Player is null. Cannot spawn item.");
						return new string[1] { "???" };
					}
					string text = RepoWebListener.AllowedValuables.Keys.ElementAt(PencilUtils.Randomizer.Next(RepoWebListener.AllowedValuables.Count));
					ValuableObject valuableThatContainsName = Valuables.GetValuableThatContainsName(text);
					if ((Object)(object)valuableThatContainsName == (Object)null)
					{
						RepoWebListener.Logger.LogError((object)$"Valuable {text} not found out of {Valuables.GetValuables().Count} valuables. Cannot spawn.");
						ManualLogSource logger = RepoWebListener.Logger;
						GameObject? obj = Valuables.GetValuables().FirstOrDefault();
						logger.LogError((object)("First valuable: " + ((obj != null) ? ((Object)obj).name : null)));
						return new string[1] { "???" };
					}
					Valuables.SpawnValuable(valuableThatContainsName, ((Component)player).transform.position + ((Component)player).transform.up * 0.2f, Quaternion.identity);
					return new string[1] { text.Replace("Valuable ", "") };
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			PunManager punManager = PunManager.instance;
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllEnergy)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Energy", new List<string> { "<b>%chatter%</b> upgraded everyone's energy!", "<b>%chatter%</b> used a power crystal to upgrade everyone's energy!", "Everyone feels more energetic thanks to <b>%chatter%</b>!", "<b>%chatter%</b> bought an energy drink and shared it with everyone!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer3 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerEnergy(alivePlayer3.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificEnergy)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Energy", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s energy!", "<b>%chatter%</b> used a power crystal to upgrade <b>%victim%</b>'s energy!", "<b>%victim%</b> feels more energetic thanks to <b>%chatter%</b>!", "<b>%chatter%</b> bought an energy drink and shared it with <b>%victim%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerEnergy(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllHealth)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Health", new List<string> { "<b>%chatter%</b> upgraded everyone's health!", "Everyone feels healthier thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer4 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerHealth(alivePlayer4.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificHealth)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Health", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s health!", "<b>%victim%</b> feels healthier thanks to <b>%chatter%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerHealth(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllGrabStrength)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Grab Strength", new List<string> { "<b>%chatter%</b> upgraded everyone's grab strength!", "Everyone feels stronger thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer5 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerGrabStrength(alivePlayer5.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificGrabStrength)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Grab Strength", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s grab strength!", "<b>%victim%</b> feels stronger thanks to <b>%chatter%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerGrabStrength(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllRange)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Range", new List<string> { "<b>%chatter%</b> upgraded everyone's grab range!", "Everyone feels more agile thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer6 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerGrabRange(alivePlayer6.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificRange)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Range", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s grab range!", "<b>%victim%</b> feels more agile thanks to <b>%chatter%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerGrabRange(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllExtraJump)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Extra Jump", new List<string> { "<b>%chatter%</b> upgraded everyone's extra jump!", "Everyone feels more jumpy thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer7 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerExtraJump(alivePlayer7.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificExtraJump)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Extra Jump", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s extra jump!", "<b>%victim%</b> feels more jumpy thanks to <b>%chatter%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerExtraJump(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllSpeed)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Speed", new List<string> { "<b>%chatter%</b> upgraded everyone's speed!", "Everyone feels faster thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer8 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerSprintSpeed(alivePlayer8.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificSpeed)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Speed", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s speed!", "<b>%victim%</b> feels faster thanks to <b>%chatter%</b>!", "<b>%chatter%</b> gave <b>%victim%</b> a speed boost!", "<b>%chatter%</b> is running CIRCLES around y'all!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerSprintSpeed(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllTumbleLaunch)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Tumble Launch", new List<string> { "<b>%chatter%</b> upgraded everyone's tumble launch!", "Everyone has stronger foreheads thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer9 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradePlayerTumbleLaunch(alivePlayer9.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificTumbleLaunch)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Tumble Launch", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s tumble launch!", "<b>%victim%</b> has a stronger forehead thanks to <b>%chatter%</b>!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradePlayerTumbleLaunch(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeAllMapPlayerCount)
			{
				PossibleGoodActions.Add(new EAction("Upgrade All Map Player Count", new List<string> { "<b>%chatter%</b> upgraded everyone's map!", "<b>%chatter%</b> wanted to make sure everyone can see each other!", "<b>%chatter%</b> wants everyone to press TAB!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar alivePlayer10 in PencilUtils.GetAlivePlayers())
					{
						punManager.UpgradeMapPlayerCount(alivePlayer10.steamID);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventUpgradeSpecificMapPlayerCount)
			{
				PossibleGoodActions.Add(new EAction("Upgrade Specific Map Player Count", new List<string> { "<b>%chatter%</b> upgraded <b>%victim%</b>'s map!" }, isForAll: false, delegate(PlayerAvatar? player)
				{
					if ((Object)(object)player == (Object)null)
					{
						return new string[1] { "???" };
					}
					punManager.UpgradeMapPlayerCount(player.steamID);
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: false, isForOnlyAlivePlayers: true));
			}
			if (PencilUtils.PencilConfig.GoodEventReviveAll && PencilUtils.GetDeadPlayers().Count > 0)
			{
				PossibleGoodActions.Add(new EAction("Revive All", new List<string> { "<b>%chatter%</b> revived everyone!", "Everyone is back to life thanks to <b>%chatter%</b>!" }, isForAll: true, delegate
				{
					foreach (PlayerAvatar deadPlayer in PencilUtils.GetDeadPlayers())
					{
						deadPlayer.Revive(false);
					}
					return Array.Empty<string>();
				}, isForOnlyDeadPlayers: true));
			}
			if (!PencilUtils.PencilConfig.GoodEventReviveSpecific || PencilUtils.GetDeadPlayers().Count <= 0)
			{
				return;
			}
			PossibleGoodActions.Add(new EAction("Revive Specific", new List<string> { "<b>%chatter%</b> revived <b>%victim%</b>!", "<b>%victim%</b> is back to life thanks to <b>%chatter%</b>!", "<b>%chatter%</b> used a revive potion on <b>%victim%</b>!", "<b>%chatter%</b> brought <b>%victim%</b> back to life!", "<b>%chatter%</b> used a defibrillator on <b>%victim%</b>!", "<b>%chatter%</b> brought <b>%victim%</b> back from the dead!" }, isForAll: false, delegate(PlayerAvatar? player)
			{
				if ((Object)(object)player == (Object)null)
				{
					return new string[1] { "???" };
				}
				player.Revive(false);
				return Array.Empty<string>();
			}, isForOnlyDeadPlayers: true));
		}

		public static string AddEventToQueueFrom(string chatter)
		{
			Event @event = Event.Generate(chatter);
			EventQueue.Enqueue(@event);
			RepoWebListener.Logger.LogInfo((object)$"Event added to queue: {@event}");
			return @event.ChatterMessage;
		}

		public static void RunNextEvent()
		{
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			if (EventQueue.Count == 0)
			{
				return;
			}
			Event @event = EventQueue.Dequeue();
			string text;
			if (!@event.Action.IsForAll)
			{
				Func<List<PlayerAvatar>> func = (@event.Action.IsForOnlyDeadPlayers ? new Func<List<PlayerAvatar>>(PencilUtils.GetDeadPlayers) : ((!@event.Action.IsForOnlyAlivePlayers) ? new Func<List<PlayerAvatar>>(PencilUtils.GetAllPlayers) : new Func<List<PlayerAvatar>>(PencilUtils.GetAlivePlayers)));
				List<PlayerAvatar> list = func();
				if (list.Count == 0)
				{
					return;
				}
				PlayerAvatar player = func()[PencilUtils.Randomizer.Next(PencilUtils.GetAlivePlayers().Count)];
				text = @event.Execute(player);
			}
			else
			{
				text = @event.Execute();
			}
			RepoWebListener.Logger.LogInfo((object)string.Format("Event executed: {0} ({1})", @event.Action.Name, @event.Action.IsForAll ? "All" : ((string)(object)@event.Action.Victim)));
			RepoWebListener.Logger.LogInfo((object)("Result: " + text));
			MissionOptions val = MissionOptions.Create((@event.Action.Type == EType.BAD) ? "<color=#CC250B>" : ("<color=#7DCC0B>" + text + "</color>"), Color.white, Color.white, (float)(PencilUtils.PencilConfig.MinimumTimeBetweenEvents - PencilUtils.PencilConfig.MinimumTimeBetweenEvents / 4));
			MissionUI.instance.MissionText("%broadcast%" + ((@event.Action.Type == EType.BAD) ? "<color=#CC250B>" : "<color=#7DCC0B>") + text + "</color>", Color.white, Color.white, (float)(PencilUtils.PencilConfig.MinimumTimeBetweenEvents - PencilUtils.PencilConfig.MinimumTimeBetweenEvents / 4));
		}
	}
	internal class PencilUtils
	{
		public static Random Randomizer = new Random();

		public static RepoWebListenerConfigActivator PencilConfig { get; private set; } = null;


		public static void Initialize(RepoWebListenerConfigActivator config)
		{
			PencilConfig = config;
		}

		public static bool IsBlacklistedLevel()
		{
			HashSet<Level> hashSet = new HashSet<Level>
			{
				RunManager.instance.levelLobby,
				RunManager.instance.levelTutorial,
				RunManager.instance.levelLobbyMenu,
				RunManager.instance.levelMainMenu,
				RunManager.instance.levelRecording
			};
			if (!PencilConfig.EnabledInShopLevel)
			{
				hashSet.Add(RunManager.instance.levelShop);
			}
			if (!PencilConfig.EnabledInArenaLevel)
			{
				hashSet.Add(RunManager.instance.levelArena);
			}
			return hashSet.Contains(RunManager.instance.levelCurrent);
		}

		public static List<PlayerAvatar> GetAllPlayers()
		{
			return SemiFunc.PlayerGetAll().ToList();
		}

		public static List<PlayerAvatar> GetAlivePlayers()
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			foreach (PlayerAvatar allPlayer in GetAllPlayers())
			{
				if (allPlayer.playerHealth.health > 0)
				{
					list.Add(allPlayer);
				}
			}
			return list;
		}

		public static List<PlayerAvatar> GetDeadPlayers()
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			foreach (PlayerAvatar allPlayer in GetAllPlayers())
			{
				if (allPlayer.playerHealth.health <= 0)
				{
					list.Add(allPlayer);
				}
			}
			return list;
		}

		public static Dictionary<string, string> GetAllowedItems()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			foreach (string key in PencilConfig.WhitelistedItems.Keys)
			{
				if (PencilConfig.WhitelistedItems[key].Value)
				{
					dictionary.Add(key, Dictionaries.ItemPaths[key]);
				}
			}
			return dictionary;
		}

		public static Dictionary<string, string> GetAllowedValuables()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			foreach (string key in PencilConfig.WhitelistedValuables.Keys)
			{
				if (PencilConfig.WhitelistedValuables[key].Value)
				{
					dictionary.Add(key, Dictionaries.ValuablePaths[key]);
				}
			}
			return dictionary;
		}

		public static Dictionary<string, EnemySetup> GetAllowedEnemies()
		{
			List<EnemySetup> enemiesDifficulty = EnemyDirector.instance.enemiesDifficulty1;
			List<EnemySetup> enemiesDifficulty2 = EnemyDirector.instance.enemiesDifficulty2;
			List<EnemySetup> enemiesDifficulty3 = EnemyDirector.instance.enemiesDifficulty3;
			List<EnemySetup> list = new List<EnemySetup>(enemiesDifficulty.Count + enemiesDifficulty2.Count + enemiesDifficulty3.Count);
			list.AddRange(enemiesDifficulty);
			list.AddRange(enemiesDifficulty2);
			list.AddRange(enemiesDifficulty3);
			List<EnemySetup> source = list;
			Dictionary<string, EnemySetup> dictionary = new Dictionary<string, EnemySetup>(StringComparer.OrdinalIgnoreCase);
			foreach (string item in PencilConfig.WhitelistedEnemies.Keys)
			{
				if (PencilConfig.WhitelistedEnemies[item].Value)
				{
					EnemySetup val = ((IEnumerable<EnemySetup>)source).FirstOrDefault((Func<EnemySetup, bool>)((EnemySetup x) => ((Object)x).name == "Enemy - " + item));
					if ((Object)(object)val != (Object)null)
					{
						dictionary.Add(item, val);
					}
					else
					{
						RepoWebListener.Logger.LogError((object)("Enemy " + item + " not found. Cannot add to allowed enemies."));
					}
				}
			}
			return dictionary;
		}
	}
	[BepInPlugin("PencilFoxStudios.RepoWebListener", "RepoWebListener", "1.0.7")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class RepoWebListener : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <GoThroughChattersCoroutine>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoWebListener <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GoThroughChattersCoroutine>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Expected O, but got Unknown
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (Events.EventQueue.Count == 0 || !SemiFunc.IsMultiplayer() || PencilUtils.IsBlacklistedLevel() || !LevelGenerator.Instance.Generated || ((!((Object)(object)RunManager.instance.levelArena == (Object)(object)RunManager.instance.levelCurrent) || !PencilUtils.PencilConfig.EnabledInArenaLevel) && RoundDirector.instance.extractionPointsCompleted == 0 && !RoundDirector.instance.extractionPointActive))
				{
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				}
				Events.RunNextEvent();
				<>2__current = (object)new WaitForSeconds((float)Math.Max(PencilUtils.PencilConfig.MinimumTimeBetweenEvents, 3));
				<>1__state = 2;
				return true;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static HttpListener listener = new HttpListener();

		private string url = "http://localhost";

		private CancellationTokenSource cts = new CancellationTokenSource();

		public static Dictionary<string, string> AllowedItems = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static Dictionary<string, string> AllowedValuables = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

		public static Dictionary<string, EnemySetup> AllowedEnemies = new Dictionary<string, EnemySetup>(StringComparer.OrdinalIgnoreCase);

		private static Dictionary<string, EnemySetup> enemySetups = new Dictionary<string, EnemySetup>();

		internal static RepoWebListener Instance { get; private set; } = null;


		public static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			Patch();
			PencilUtils.Initialize(new RepoWebListenerConfigActivator(((BaseUnityPlugin)this).Config));
			url = $"http://{PencilUtils.PencilConfig.WebServerListenIP}:{PencilUtils.PencilConfig.WebServerListenPort}/";
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} has loaded!");
			if (PencilUtils.PencilConfig.WebServerEnabled)
			{
				Logger.LogInfo((object)"Starting web server...");
				listener.Prefixes.Add(url);
				listener.Start();
				Logger.LogInfo((object)("Listening on " + url));
			}
			else
			{
				Logger.LogInfo((object)"Web server is disabled. Check the config file to enable it.");
			}
			Task.Run(() => ListenLoop(cts.Token));
			((MonoBehaviour)this).StartCoroutine(GoThroughChattersCoroutine());
		}

		private void Start()
		{
			Logger.LogInfo((object)"RepoWebListener is ready!");
			Events.Init();
		}

		[IteratorStateMachine(typeof(<GoThroughChattersCoroutine>d__21))]
		private IEnumerator GoThroughChattersCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GoThroughChattersCoroutine>d__21(0)
			{
				<>4__this = this
			};
		}

		private async Task ListenLoop(CancellationToken token)
		{
			try
			{
				while (!token.IsCancellationRequested)
				{
					HandleRequest(await listener.GetContextAsync());
				}
			}
			catch (HttpListenerException ex3)
			{
				HttpListenerException ex2 = ex3;
				Logger.LogWarning((object)("Listener stopped: " + ex2.Message));
			}
			catch (Exception ex4)
			{
				Exception ex = ex4;
				Logger.LogError((object)$"Error in ListenLoop: {ex}");
			}
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal void Unpatch()
		{
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void OnDestroy()
		{
			cts.Cancel();
			if (listener.IsListening)
			{
				listener.Stop();
				listener.Close();
			}
			Unpatch();
		}

		private void HandleRequest(HttpListenerContext context)
		{
			HttpListenerRequest request = context.Request;
			Logger.LogInfo((object)("Received " + request.HttpMethod + " request"));
			if (request.HttpMethod == "GET")
			{
				string chatter = request.QueryString["username"];
				HttpListenerResponse response = context.Response;
				string s = Events.AddEventToQueueFrom(chatter);
				byte[] bytes = Encoding.UTF8.GetBytes(s);
				response.ContentLength64 = bytes.Length;
				response.OutputStream.Write(bytes, 0, bytes.Length);
				response.OutputStream.Close();
				Logger.LogInfo((object)$"Chatters in queue: {Events.EventQueue.Count}");
			}
			else
			{
				context.Response.StatusCode = 405;
				context.Response.Close();
			}
		}

		private void Update()
		{
		}
	}
	internal class RepoWebListenerConfigActivator
	{
		private readonly ConfigEntry<int> webServerListenPort;

		private readonly ConfigEntry<string> webServerListenIP;

		private readonly ConfigEntry<bool> webServerEnabled;

		private readonly ConfigEntry<bool> enabledInShopLevel;

		private readonly ConfigEntry<bool> enabledInArenaLevel;

		private readonly ConfigEntry<bool> goodThings;

		private readonly ConfigEntry<int> minimumTimeBetweenEvents;

		private readonly ConfigEntry<bool> badThings;

		private readonly ConfigEntry<bool> goodEventHealAll;

		private readonly ConfigEntry<bool> goodEventHealSpecific;

		private readonly ConfigEntry<int> goodEventHealMinAmount;

		private readonly ConfigEntry<int> goodEventHealMaxAmount;

		private readonly ConfigEntry<bool> goodEventUpgradeAllEnergy;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificEnergy;

		private readonly ConfigEntry<bool> goodEventUpgradeAllHealth;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificHealth;

		private readonly ConfigEntry<bool> goodEventUpgradeAllGrabStrength;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificGrabStrength;

		private readonly ConfigEntry<bool> goodEventUpgradeAllRange;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificRange;

		private readonly ConfigEntry<bool> goodEventUpgradeAllSpeed;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificSpeed;

		private readonly ConfigEntry<bool> goodEventUpgradeAllExtraJump;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificExtraJump;

		private readonly ConfigEntry<bool> goodEventUpgradeAllTumbleLaunch;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificTumbleLaunch;

		private readonly ConfigEntry<bool> goodEventUpgradeAllMapPlayerCount;

		private readonly ConfigEntry<bool> goodEventUpgradeSpecificMapPlayerCount;

		private readonly ConfigEntry<bool> goodEventSpawnRandomItem;

		public Dictionary<string, ConfigEntry<bool>> WhitelistedItems = new Dictionary<string, ConfigEntry<bool>>();

		private readonly ConfigEntry<bool> goodEventSpawnRandomValuable;

		private readonly ConfigEntry<bool> goodEventReviveSpecific;

		private readonly ConfigEntry<bool> goodEventReviveAll;

		public Dictionary<string, ConfigEntry<bool>> WhitelistedValuables = new Dictionary<string, ConfigEntry<bool>>();

		private readonly ConfigEntry<bool> badEventDamageAll;

		private readonly ConfigEntry<bool> badEventDamageSpecific;

		private readonly ConfigEntry<int> badEventDamageMinAmount;

		private readonly ConfigEntry<int> badEventDamageMaxAmount;

		private readonly ConfigEntry<bool> badEventDamageCanKill;

		private readonly ConfigEntry<bool> badEventSpawnRandomEnemy;

		public Dictionary<string, ConfigEntry<bool>> WhitelistedEnemies = new Dictionary<string, ConfigEntry<bool>>();

		public int WebServerListenPort => webServerListenPort.Value;

		public string WebServerListenIP => webServerListenIP.Value;

		public bool WebServerEnabled => webServerEnabled.Value;

		public bool EnabledInShopLevel => enabledInShopLevel.Value;

		public bool EnabledInArenaLevel => enabledInArenaLevel.Value;

		public bool GoodThings => goodThings.Value;

		public int MinimumTimeBetweenEvents => minimumTimeBetweenEvents.Value;

		public bool BadThings => badThings.Value;

		public bool GoodEventHealAll => goodEventHealAll.Value;

		public bool GoodEventHealSpecific => goodEventHealSpecific.Value;

		public int GoodEventHealMinAmount => goodEventHealMinAmount.Value;

		public int GoodEventHealMaxAmount => goodEventHealMaxAmount.Value;

		public bool GoodEventUpgradeAllEnergy => goodEventUpgradeAllEnergy.Value;

		public bool GoodEventUpgradeSpecificEnergy => goodEventUpgradeSpecificEnergy.Value;

		public bool GoodEventUpgradeAllHealth => goodEventUpgradeAllHealth.Value;

		public bool GoodEventUpgradeSpecificHealth => goodEventUpgradeSpecificHealth.Value;

		public bool GoodEventUpgradeAllGrabStrength => goodEventUpgradeAllGrabStrength.Value;

		public bool GoodEventUpgradeSpecificGrabStrength => goodEventUpgradeSpecificGrabStrength.Value;

		public bool GoodEventUpgradeAllRange => goodEventUpgradeAllRange.Value;

		public bool GoodEventUpgradeSpecificRange => goodEventUpgradeSpecificRange.Value;

		public bool GoodEventUpgradeAllSpeed => goodEventUpgradeAllSpeed.Value;

		public bool GoodEventUpgradeSpecificSpeed => goodEventUpgradeSpecificSpeed.Value;

		public bool GoodEventUpgradeAllExtraJump => goodEventUpgradeAllExtraJump.Value;

		public bool GoodEventUpgradeSpecificExtraJump => goodEventUpgradeSpecificExtraJump.Value;

		public bool GoodEventUpgradeAllTumbleLaunch => goodEventUpgradeAllTumbleLaunch.Value;

		public bool GoodEventUpgradeSpecificTumbleLaunch => goodEventUpgradeSpecificTumbleLaunch.Value;

		public bool GoodEventUpgradeAllMapPlayerCount => goodEventUpgradeAllMapPlayerCount.Value;

		public bool GoodEventUpgradeSpecificMapPlayerCount => goodEventUpgradeSpecificMapPlayerCount.Value;

		public bool GoodEventSpawnRandomItem => goodEventSpawnRandomItem.Value;

		public bool GoodEventSpawnRandomValuable => goodEventSpawnRandomValuable.Value;

		public bool GoodEventReviveSpecific => goodEventReviveSpecific.Value;

		public bool GoodEventReviveAll => goodEventReviveAll.Value;

		public bool BadEventDamageAll => badEventDamageAll.Value;

		public bool BadEventDamageSpecific => badEventDamageSpecific.Value;

		public int BadEventDamageMinAmount => badEventDamageMinAmount.Value;

		public int BadEventDamageMaxAmount => badEventDamageMaxAmount.Value;

		public bool BadEventDamageCanKill => badEventDamageCanKill.Value;

		public bool BadEventSpawnRandomEnemy => badEventSpawnRandomEnemy.Value;

		public RepoWebListenerConfigActivator(ConfigFile cfg)
		{
			webServerEnabled = cfg.Bind<bool>("Web Server", "WebServerEnabled", true, "Should I start the web server?\nIf you don't plan on being the host, you can probably turn this off.");
			webServerListenPort = cfg.Bind<int>("Web Server", "WebServerListenPort", 7390, "What port should I listen on for requests? (i.e. http://localhost:XXXX)");
			webServerListenIP = cfg.Bind<string>("Web Server", "WebServerListenIP", "localhost", "What IP should I listen on for requests? (i.e. http://XXXX:7390)\nIf you're unsure, leave this as localhost!");
			if (webServerListenPort.Value < 1024 || webServerListenPort.Value > 65535)
			{
				RepoWebListener.Logger.LogError((object)"Port must be between 1024 and 65535. Defaulting to 7390.");
				webServerListenPort.Value = 7390;
			}
			if (string.IsNullOrEmpty(webServerListenIP.Value))
			{
				RepoWebListener.Logger.LogError((object)"IP must be a valid IP address. Defaulting to localhost.");
				webServerListenIP.Value = "localhost";
			}
			enabledInShopLevel = cfg.Bind<bool>("Levels", "EnabledInShopLevel", true, "Should I send events when you're in the shop level?");
			enabledInArenaLevel = cfg.Bind<bool>("Levels", "EnabledInArenaLevel", true, "Should I send events when you're in the arena level?");
			minimumTimeBetweenEvents = cfg.Bind<int>("Events.General", "MinimumTimeBetweenEvents", 10, "How long should I wait between events in the queue?\nThis is in seconds, and has a hard-coded minimum of 3 seconds.");
			if (minimumTimeBetweenEvents.Value < 3)
			{
				RepoWebListener.Logger.LogWarning((object)"To avoid spamming the multiplayer servers, the minimum time between events must be at least 3 seconds. Setting to 3.");
				minimumTimeBetweenEvents.Value = 3;
			}
			goodThings = cfg.Bind<bool>("Events.General", "GoodEvents", true, "Should I enable good things happening to players?\nSetting this to false will disable all good events.");
			badThings = cfg.Bind<bool>("Events.General", "BadEvents", true, "Should I enable bad things happening to players?\nSetting this to false will disable all bad events.");
			goodEventHealAll = cfg.Bind<bool>("Good Events.Healing", "GoodEventHealAll", true, "Should healing all players be a possible event?");
			goodEventHealSpecific = cfg.Bind<bool>("Good Events.Healing", "GoodEventHealSpecific", true, "Should healing a specific player be a possible event?\nSetting this to false will ignore GoodEventHealMaxAmount.");
			goodEventReviveSpecific = cfg.Bind<bool>("Good Events.Healing", "GoodEventReviveSpecific", true, "Should reviving a specific player be a possible event?");
			goodEventReviveAll = cfg.Bind<bool>("Good Events.Healing", "GoodEventReviveAll", true, "Should reviving all players be a possible event?");
			goodEventHealMinAmount = cfg.Bind<int>("Good Events.Healing", "GoodEventHealMinAmount", 0, "What's the minimum healing I'm allowed to grant per goodEventHealAll/GoodEventHealSpecific event?\nA random amount between this value and GoodEventHealMaxAmount and this value will rolled per player.");
			goodEventHealMaxAmount = cfg.Bind<int>("Good Events.Healing", "GoodEventHealMaxAmount", 25, "What's the maximum healing I'm allowed to grant per goodEventHealAll/GoodEventHealSpecific event?\nA random amount between GoodEventHealMinAmount and this value will rolled per player.");
			goodEventUpgradeAllEnergy = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllEnergy", true, "Should upgrading all players' stamina be a possible event?");
			goodEventUpgradeSpecificEnergy = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificEnergy", true, "Should upgrading a specific player's stamina be a possible event?");
			goodEventUpgradeAllHealth = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllHealth", true, "Should upgrading all players' health be a possible event?");
			goodEventUpgradeSpecificHealth = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificHealth", true, "Should upgrading a specific player's health be a possible event?");
			goodEventUpgradeAllGrabStrength = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllGrabStrength", true, "Should upgrading all players' strength be a possible event?");
			goodEventUpgradeSpecificGrabStrength = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificGrabStrength", true, "Should upgrading a specific player's strength be a possible event?");
			goodEventUpgradeAllRange = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllRange", true, "Should upgrading all players' grab range be a possible event?");
			goodEventUpgradeSpecificRange = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificRange", true, "Should upgrading a specific player's grab range be a possible event?");
			goodEventUpgradeAllSpeed = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllSpeed", true, "Should upgrading all players' sprint speed be a possible event?");
			goodEventUpgradeSpecificSpeed = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificSpeed", true, "Should upgrading a specific player's sprint speed be a possible event?");
			goodEventUpgradeAllExtraJump = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllExtraJump", true, "Should upgrading all players' extra jumps (+1) be a possible event?");
			goodEventUpgradeSpecificExtraJump = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificExtraJump", true, "Should upgrading a specific player's extra jumps (+1) be a possible event?");
			goodEventUpgradeAllTumbleLaunch = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllTumbleLaunch", true, "Should upgrading all players' tumble launch be a possible event?");
			goodEventUpgradeSpecificTumbleLaunch = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificTumbleLaunch", true, "Should upgrading a specific player's tumble launch be a possible event?");
			goodEventUpgradeAllMapPlayerCount = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeAllMapPlayerCount", true, "Should upgrading all players' map player count be a possible event?");
			goodEventUpgradeSpecificMapPlayerCount = cfg.Bind<bool>("Good Events.Upgrading", "GoodEventUpgradeSpecificMapPlayerCount", true, "Should upgrading a specific player's map player count be a possible event?");
			goodEventSpawnRandomItem = cfg.Bind<bool>("Good Events.Item Spawning", "GoodEventSpawnRandomItem", true, "Should spawning a random item near a random player be a possible event?\nSetting this to false will ignore all below events starting with GoodEventSpawnItem");
			bool flag = false;
			foreach (KeyValuePair<string, string> itemPath in Dictionaries.ItemPaths)
			{
				WhitelistedItems[itemPath.Key] = cfg.Bind<bool>("Good Events.Item Spawning", "GoodEventSpawn" + itemPath.Key, true, "Should a \"" + itemPath.Key.Replace("Item", "") + "\" item be possible for GoodEventSpawnRandomItem?");
				if (WhitelistedItems[itemPath.Key].Value)
				{
					flag = true;
				}
			}
			if (!flag)
			{
				goodEventSpawnRandomItem.Value = false;
				RepoWebListener.Logger.LogWarning((object)"All items are disabled. Assuming GoodEventSpawnRandomItem config entry to false.");
			}
			goodEventSpawnRandomValuable = cfg.Bind<bool>("Good Events.Valuable Spawning", "GoodEventSpawnRandomValuable", true, "Should spawning a random Valuable be a possible event?\nSetting this to false will ignore all below events starting with GoodEventSpawnValuable.");
			bool flag2 = false;
			foreach (KeyValuePair<string, string> valuablePath in Dictionaries.ValuablePaths)
			{
				WhitelistedValuables[valuablePath.Key] = cfg.Bind<bool>("Good Events.Valuable Spawning", "GoodEventSpawn" + valuablePath.Key, true, "Should a \"" + valuablePath.Key.Replace("Valuable", "") + "\" valuable be possible for GoodEventSpawnRandomValuable?");
				if (WhitelistedValuables[valuablePath.Key].Value)
				{
					flag2 = true;
				}
			}
			if (!flag2)
			{
				goodEventSpawnRandomValuable.Value = false;
				RepoWebListener.Logger.LogWarning((object)"All valuables are disabled. Assuming GoodEventSpawnRandomValuable config entry to false.");
			}
			if (!GoodThings || (!GoodEventHealAll && !GoodEventHealSpecific && !GoodEventUpgradeAllEnergy && !GoodEventUpgradeSpecificEnergy && !GoodEventUpgradeAllHealth && !GoodEventUpgradeSpecificHealth && !GoodEventUpgradeAllGrabStrength && !GoodEventUpgradeSpecificGrabStrength && !GoodEventUpgradeAllRange && !GoodEventUpgradeSpecificRange && !GoodEventUpgradeAllSpeed && !GoodEventUpgradeSpecificSpeed && !GoodEventUpgradeAllExtraJump && !GoodEventUpgradeSpecificExtraJump && !GoodEventUpgradeAllTumbleLaunch && !GoodEventUpgradeSpecificTumbleLaunch && !GoodEventUpgradeAllMapPlayerCount && !GoodEventUpgradeSpecificMapPlayerCount && !GoodEventSpawnRandomItem && !GoodEventSpawnRandomValuable && !GoodEventReviveSpecific && !GoodEventReviveAll))
			{
				goodThings.Value = false;
				RepoWebListener.Logger.LogWarning((object)"All good events are disabled. Assuming GoodThings config entry to false.");
			}
			else
			{
				goodThings.Value = true;
			}
			badEventDamageAll = cfg.Bind<bool>("Bad Events.Damage", "BadEventDamageAll", true, "Should damaging all players be a possible event?");
			badEventDamageSpecific = cfg.Bind<bool>("Bad Events.Damage", "BadEventDamageSpecific", true, "Should damaging a specific player be a possible event?");
			badEventDamageMinAmount = cfg.Bind<int>("Bad Events.Damage", "BadEventDamageMinAmount", 0, "What's the minimum damage I'm allowed to deal per BadEventDamageAll/BadEventDamageSpecific event?\nA random amount between this value and BadEventDamageMaxAmount will rolled per player.");
			badEventDamageMaxAmount = cfg.Bind<int>("Bad Events.Damage", "BadEventDamageMaxAmount", 25, "What's the maximum damage I'm allowed to deal per BadEventDamageAll/BadEventDamageSpecific event?\nA random amount between BadEventDamageMinAmount and this value will rolled per player.");
			badEventDamageCanKill = cfg.Bind<bool>("Bad Events.Damage", "BadEventDamageCanKill", false, "Should I be allowed to finish off the player via damage?\n(If true, BadEventDamageAll/BadEventDamageSpecific will only be able to get the player(s) down to 1 health.)");
			badEventSpawnRandomEnemy = cfg.Bind<bool>("Bad Events.Enemy Spawning", "BadEventSpawnRandomEnemy", true, "Should spawning a random enemy near a random player be a possible event?\nSetting this to false will ignore all below events starting with BadEventSpawnEnemy.");
			bool flag3 = false;
			foreach (KeyValuePair<string, string> enemyPath in Dictionaries.EnemyPaths)
			{
				WhitelistedEnemies[enemyPath.Key] = cfg.Bind<bool>("Bad Events.Enemy Spawning", "BadEventSpawn" + enemyPath.Key, true, "Should a \"" + enemyPath.Key.Replace("Enemy", "") + "\" enemy be possible for BadEventSpawnRandomEnemy?");
				if (WhitelistedEnemies[enemyPath.Key].Value)
				{
					flag3 = true;
				}
			}
			if (!flag3)
			{
				badEventSpawnRandomEnemy.Value = false;
				RepoWebListener.Logger.LogWarning((object)"All enemies are disabled. Assuming BadEventSpawnRandomEnemy config entry to false.");
			}
			else
			{
				badEventSpawnRandomEnemy.Value = true;
			}
			if (!BadThings || (!BadEventDamageAll && !BadEventDamageSpecific && !BadEventSpawnRandomEnemy))
			{
				badThings.Value = false;
				RepoWebListener.Logger.LogWarning((object)"All bad events are disabled. Assuming BadThings config entry to false.");
			}
			else
			{
				badThings.Value = true;
			}
		}
	}
	[HarmonyPatch(typeof(RunManager))]
	internal class RunManagerPatch
	{
		[HarmonyPatch("ChangeLevel")]
		[HarmonyPostfix]
		private static void ChangeLevel_Postfix()
		{
			RepoWebListener.AllowedItems.Clear();
			RepoWebListener.AllowedValuables.Clear();
			RepoWebListener.AllowedEnemies.Clear();
			RepoWebListener.AllowedItems = PencilUtils.GetAllowedItems();
			RepoWebListener.AllowedValuables = PencilUtils.GetAllowedValuables();
			RepoWebListener.AllowedEnemies = PencilUtils.GetAllowedEnemies();
		}
	}
}