using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using BepinControl.Effects;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MyBox;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Photon.Pun;
using Photon.Realtime;
using REPOLib.Modules;
using TMPro;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LethalCompanyCrowdControlMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalCompanyCrowdControlMod")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("d4f6b961-e8ae-4e4b-950c-37644e42d4ca")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
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;
		}
	}
}
namespace BepinControl
{
	public class HelperUtils
	{
		public static PlayerAvatar FindPlayerAvatarByNumberOld(int actorNumber, bool alive = true, bool random = false)
		{
			List<PlayerAvatar> list = new List<PlayerAvatar>();
			foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
			{
				PhotonView component = ((Component)player).GetComponent<PhotonView>();
				if ((Object)(object)component == (Object)null)
				{
					continue;
				}
				FieldInfo field = typeof(PlayerAvatar).GetField("isDisabled", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field != null && (bool)field.GetValue(player) && alive)
				{
					continue;
				}
				if (random)
				{
					if (component.Owner.ActorNumber != actorNumber)
					{
						list.Add(player);
					}
				}
				else if (component.Owner.ActorNumber == actorNumber)
				{
					return player;
				}
			}
			if (random && list.Count > 0)
			{
				int index = Random.Range(0, list.Count);
				return list[index];
			}
			return null;
		}

		public static async Task<PlayerHealth> FindPlayerHealthByAvatarNumber(int targetActor)
		{
			TaskCompletionSource<PlayerHealth> tcs = new TaskCompletionSource<PlayerHealth>(TaskCreationOptions.RunContinuationsAsynchronously);
			await Task.Yield();
			CrowdControlMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					PlayerHealth[] array = Object.FindObjectsOfType<PlayerHealth>();
					List<PlayerHealth> list = new List<PlayerHealth>();
					PlayerHealth[] array2 = array;
					foreach (PlayerHealth val in array2)
					{
						PhotonView component = ((Component)val).GetComponent<PhotonView>();
						if ((Object)(object)component != (Object)null && component.Owner.ActorNumber == targetActor)
						{
							list.Add(val);
						}
					}
					tcs.TrySetResult(list.FirstOrDefault());
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogError((object)("Error in FindPlayerByActorNumberAsync: " + ex.Message));
					tcs.TrySetResult(null);
				}
			});
			return await tcs.Task;
		}

		public static async Task<PlayerAvatar> FindPlayerAvatarByNumber(int actorNumber, bool alive = true, bool random = false)
		{
			TaskCompletionSource<PlayerAvatar> tcs = new TaskCompletionSource<PlayerAvatar>(TaskCreationOptions.RunContinuationsAsynchronously);
			await Task.Yield();
			CrowdControlMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					List<PlayerAvatar> list = new List<PlayerAvatar>();
					foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
					{
						PhotonView component = ((Component)player).GetComponent<PhotonView>();
						if (!((Object)(object)component == (Object)null))
						{
							FieldInfo field = typeof(PlayerAvatar).GetField("isDisabled", BindingFlags.Instance | BindingFlags.NonPublic);
							if (!(field != null && (bool)field.GetValue(player) && alive))
							{
								if (random)
								{
									if (component.Owner.ActorNumber != actorNumber)
									{
										list.Add(player);
									}
								}
								else if (component.Owner.ActorNumber == actorNumber)
								{
									tcs.TrySetResult(player);
									return;
								}
							}
						}
					}
					if (random && list.Count > 0)
					{
						int index = Random.Range(0, list.Count);
						PlayerAvatar result = list[index];
						tcs.TrySetResult(result);
					}
					else
					{
						tcs.TrySetResult(null);
					}
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogError((object)("Error in FindPlayerAvatarByNumberAsync: " + ex.Message));
					tcs.TrySetResult(null);
				}
			});
			return await tcs.Task;
		}

		public static async Task<PlayerAvatar> FindRandomAvatar(int actorNumber)
		{
			TaskCompletionSource<PlayerAvatar> tcs = new TaskCompletionSource<PlayerAvatar>(TaskCreationOptions.RunContinuationsAsynchronously);
			await Task.Yield();
			CrowdControlMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					List<PlayerAvatar> list = new List<PlayerAvatar>();
					foreach (PlayerAvatar player in GameDirector.instance.PlayerList)
					{
						PhotonView component = ((Component)player).GetComponent<PhotonView>();
						if (!((Object)(object)component == (Object)null) && component.Owner.ActorNumber != actorNumber)
						{
							list.Add(player);
						}
					}
					if (list.Count > 0)
					{
						tcs.TrySetResult(null);
					}
					int index = Random.Range(0, list.Count);
					PlayerAvatar val = list[index];
					if (Object.op_Implicit((Object)(object)val))
					{
						tcs.TrySetResult(val);
					}
					tcs.TrySetResult(null);
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogError((object)("Error in FindRandomPlayer: " + ex.Message));
					tcs.TrySetResult(null);
				}
			});
			return await tcs.Task;
		}
	}
	public enum TimedType
	{
		INVINCIBLE,
		INFINITE_STAMINA,
		ANTI_GRAVITY,
		DISABLE_CROUCH,
		DISABLE_INPUT,
		FEATHER,
		SPEED,
		PRAISE,
		KILL
	}
	public class Timed
	{
		public TimedType type;

		private float old;

		public int duration;

		private static Dictionary<string, object> customVariables = new Dictionary<string, object>();

		private static int frames = 0;

		public static T GetCustomVariable<T>(string key)
		{
			if (customVariables.TryGetValue(key, out var value))
			{
				return (T)value;
			}
			throw new KeyNotFoundException("Custom variable with key '" + key + "' not found.");
		}

		public void SetCustomVariables(Dictionary<string, object> variables)
		{
			customVariables = variables;
		}

		public Timed(TimedType t)
		{
			type = t;
		}

		public void addEffect()
		{
			_ = (float)duration / 1000f;
			switch (type)
			{
			case TimedType.INVINCIBLE:
				CrowdControlMod.infiniteHealth = true;
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance6 = Singleton<MissionUI>.Instance;
					if (instance6 != null)
					{
						instance6.MissionText("CC Infinite Health activated", Color.green, Color.green, 1f);
					}
				});
				break;
			case TimedType.INFINITE_STAMINA:
				CrowdControlMod.infiniteStamina = true;
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance3 = Singleton<MissionUI>.Instance;
					if (instance3 != null)
					{
						instance3.MissionText("CC Infinite Energy activated", Color.green, Color.green, 1f);
					}
				});
				break;
			case TimedType.SPEED:
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance5 = Singleton<MissionUI>.Instance;
					if (instance5 != null)
					{
						instance5.MissionText("CC Increased Speed activated", Color.green, Color.green, 1f);
					}
				});
				break;
			case TimedType.ANTI_GRAVITY:
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance2 = Singleton<MissionUI>.Instance;
					if (instance2 != null)
					{
						instance2.MissionText("CC Anti-Gravity activated", Color.green, Color.green, 1f);
					}
				});
				break;
			case TimedType.DISABLE_CROUCH:
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance = Singleton<MissionUI>.Instance;
					if (instance != null)
					{
						instance.MissionText("CC Crouch is disabled", Color.red, Color.red, 1f);
					}
				});
				break;
			case TimedType.DISABLE_INPUT:
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance4 = Singleton<MissionUI>.Instance;
					if (instance4 != null)
					{
						instance4.MissionText("CC All inputs disabled", Color.red, Color.red, 1f);
					}
				});
				break;
			case TimedType.FEATHER:
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0014: Unknown result type (might be due to invalid IL or missing references)
					MissionUI instance7 = Singleton<MissionUI>.Instance;
					if (instance7 != null)
					{
						instance7.MissionText("CC Feather activated", Color.green, Color.green, 1f);
					}
				});
				break;
			}
		}

		public static bool removeEffect(TimedType etype)
		{
			try
			{
				switch (etype)
				{
				case TimedType.INVINCIBLE:
					CrowdControlMod.infiniteHealth = false;
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance6 = Singleton<MissionUI>.Instance;
						if (instance6 != null)
						{
							instance6.MissionText("CC Infinite Health deactivated", Color.red, Color.red, 1f);
						}
					});
					break;
				case TimedType.INFINITE_STAMINA:
					CrowdControlMod.infiniteStamina = false;
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance3 = Singleton<MissionUI>.Instance;
						if (instance3 != null)
						{
							instance3.MissionText("CC Infinite Energy deactivated", Color.red, Color.red, 1f);
						}
					});
					break;
				case TimedType.SPEED:
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance5 = Singleton<MissionUI>.Instance;
						if (instance5 != null)
						{
							instance5.MissionText("CC Increased Speed deactivated", Color.red, Color.red, 1f);
						}
					});
					break;
				case TimedType.ANTI_GRAVITY:
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance2 = Singleton<MissionUI>.Instance;
						if (instance2 != null)
						{
							instance2.MissionText("CC Anti-Gravity deactivated", Color.red, Color.red, 1f);
						}
					});
					break;
				case TimedType.DISABLE_CROUCH:
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance = Singleton<MissionUI>.Instance;
						if (instance != null)
						{
							instance.MissionText("CC Crouch is enabled", Color.green, Color.green, 1f);
						}
					});
					break;
				case TimedType.DISABLE_INPUT:
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance4 = Singleton<MissionUI>.Instance;
						if (instance4 != null)
						{
							instance4.MissionText("CC All inputs recovered", Color.green, Color.green, 1f);
						}
					});
					break;
				case TimedType.FEATHER:
					CrowdControlMod.ActionQueue.Enqueue(delegate
					{
						//IL_000f: Unknown result type (might be due to invalid IL or missing references)
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						MissionUI instance7 = Singleton<MissionUI>.Instance;
						if (instance7 != null)
						{
							instance7.MissionText("CC Feather decatived", Color.red, Color.red, 1f);
						}
					});
					break;
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
				return false;
			}
			return true;
		}

		public void tick()
		{
			frames++;
			_ = type;
			_ = 1;
		}
	}
	public class TimedThread
	{
		public static List<TimedThread> threads = new List<TimedThread>();

		public readonly Timed effect;

		public int duration;

		public int remain;

		public int id;

		public bool paused;

		public static bool isRunning(TimedType t)
		{
			foreach (TimedThread thread in threads)
			{
				if (thread.effect.type == t)
				{
					return true;
				}
			}
			return false;
		}

		public static void tick()
		{
			foreach (TimedThread thread in threads)
			{
				if (!thread.paused)
				{
					thread.effect.tick();
				}
			}
		}

		public static void addTime(int duration)
		{
			try
			{
				lock (threads)
				{
					foreach (TimedThread thread in threads)
					{
						Interlocked.Add(ref thread.duration, duration + 5);
						if (!thread.paused)
						{
							int dur = Volatile.Read(ref thread.remain);
							new TimedResponse(thread.id, dur, CrowdResponse.Status.STATUS_PAUSE).Send(ControlClient.Socket);
							thread.paused = true;
						}
					}
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
			}
		}

		public static void tickTime(int duration)
		{
			try
			{
				lock (threads)
				{
					foreach (TimedThread thread in threads)
					{
						int num = Volatile.Read(ref thread.remain);
						num -= duration;
						if (num < 0)
						{
							num = 0;
						}
						Volatile.Write(ref thread.remain, num);
					}
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
			}
		}

		public static void unPause()
		{
			try
			{
				lock (threads)
				{
					foreach (TimedThread thread in threads)
					{
						if (thread.paused)
						{
							int dur = Volatile.Read(ref thread.remain);
							new TimedResponse(thread.id, dur, CrowdResponse.Status.STATUS_RESUME).Send(ControlClient.Socket);
							thread.paused = false;
						}
					}
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
			}
		}

		public TimedThread(int id, TimedType type, int duration, Dictionary<string, object> customVariables = null)
		{
			effect = new Timed(type);
			this.duration = duration;
			remain = duration;
			this.id = id;
			paused = false;
			if (customVariables == null)
			{
				customVariables = new Dictionary<string, object>();
			}
			effect.SetCustomVariables(customVariables);
			try
			{
				lock (threads)
				{
					threads.Add(this);
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
			}
		}

		public void Run()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			effect.addEffect();
			bool flag = false;
			try
			{
				do
				{
					flag = false;
					for (int num = Volatile.Read(ref duration); num > 0; num = Volatile.Read(ref duration))
					{
						Interlocked.Add(ref duration, -num);
						Thread.Sleep(num);
					}
					if (Timed.removeEffect(effect.type))
					{
						lock (threads)
						{
							threads.Remove(this);
						}
						new TimedResponse(id, 0, CrowdResponse.Status.STATUS_STOP).Send(ControlClient.Socket);
					}
					else
					{
						flag = true;
					}
				}
				while (flag);
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogInfo((object)ex.ToString());
			}
		}
	}
	[BepInPlugin("WarpWorld.CrowdControl", "Crowd Control", "1.0.6.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class CrowdControlMod : BaseUnityPlugin
	{
		[HarmonyPatch(typeof(RunManager))]
		[HarmonyPatch("OnApplicationQuit")]
		public class OnApplicationQuitPatch
		{
			private static bool Prefix()
			{
				try
				{
					if (ControlClient.Socket != null && ControlClient.Socket.Connected)
					{
						ControlClient.Socket.Shutdown(SocketShutdown.Both);
						ControlClient.Socket.Close();
						ControlClient.Socket.Dispose();
					}
					ControlClient.connected = false;
					new ControlClient().Stop();
					mls.LogInfo((object)"ControlClient stopped successfully.");
				}
				catch (Exception arg)
				{
					mls.LogError((object)$"Error during application quit: {arg}");
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerHealth))]
		internal class PlayerHealthPatch
		{
			[HarmonyPatch("Update")]
			[HarmonyPostfix]
			private static void UpdatePatch(PlayerHealth __instance)
			{
				Traverse.Create((object)__instance).Field("godMode").SetValue((object)infiniteHealth);
			}
		}

		[HarmonyPatch(typeof(HealthUI), "Update")]
		public class Patch_HealthUI_Update
		{
			private static bool Prefix(HealthUI __instance)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				if (infiniteHealth)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(HealthUI), "Text");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(HealthUI), "textMaxHealth");
					if (fieldInfo != null)
					{
						TextMeshProUGUI val = (TextMeshProUGUI)fieldInfo.GetValue(__instance);
						if ((Object)(object)val != (Object)null)
						{
							((TMP_Text)val).text = "INFINITE";
						}
					}
					if (fieldInfo2 != null)
					{
						TextMeshProUGUI val2 = (TextMeshProUGUI)fieldInfo2.GetValue(__instance);
						if ((Object)(object)val2 != (Object)null)
						{
							((TMP_Text)val2).text = "";
						}
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(MissionUI), "MissionText")]
		public class MissionUITextPatch
		{
			private static void Postfix(MissionUI __instance)
			{
				FieldInfo field = typeof(MissionUI).GetField("Text", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					object? value = field.GetValue(__instance);
					TMP_Text val = (TMP_Text)((value is TMP_Text) ? value : null);
					if ((Object)(object)val != (Object)null && val.text.StartsWith("<b>FOCUS > </b>CC "))
					{
						val.text = val.text.Replace("FOCUS >", "CrowdControl:").Replace("CC ", " ");
					}
				}
			}
		}

		[HarmonyPatch(typeof(EnergyUI), "Update")]
		public class Patch_EnergyUI_Update
		{
			private static bool Prefix(EnergyUI __instance)
			{
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				if (infiniteStamina)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(EnergyUI), "Text");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(EnergyUI), "textEnergyMax");
					if (fieldInfo != null)
					{
						TextMeshProUGUI val = (TextMeshProUGUI)fieldInfo.GetValue(__instance);
						if ((Object)(object)val != (Object)null)
						{
							((TMP_Text)val).text = "INFINITE";
						}
					}
					if (fieldInfo2 != null)
					{
						TextMeshProUGUI val2 = (TextMeshProUGUI)fieldInfo2.GetValue(__instance);
						if ((Object)(object)val2 != (Object)null)
						{
							((TMP_Text)val2).text = "";
						}
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(MenuPageLobby), "PlayerAdd")]
		public static class PlayerAddPatch
		{
			private static void Postfix(PlayerAvatar player)
			{
				FieldInfo field = typeof(PlayerAvatar).GetField("steamID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				string key = ((field != null) ? ((field.GetValue(player) as string) ?? "0") : "0");
				PlayerVersions[key] = "1.0.6.0";
				RPCCommands.MessageHandler.SendMessageToHost("CC_CONNECT", 0, PhotonNetwork.LocalPlayer.ActorNumber, 0, new Dictionary<string, object> { { "version", "1.0.6.0" } });
			}
		}

		[HarmonyPatch(typeof(MenuPageLobby), "Update")]
		public static class MenuPageLobbyPatch
		{
			private static void Postfix(MenuPageLobby __instance)
			{
				FieldInfo field = typeof(MenuPageLobby).GetField("listObjects", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null || !(field.GetValue(__instance) is List<GameObject> list))
				{
					return;
				}
				foreach (GameObject item in list)
				{
					MenuPlayerListed component = item.GetComponent<MenuPlayerListed>();
					if ((Object)(object)component == (Object)null)
					{
						continue;
					}
					FieldInfo field2 = typeof(MenuPlayerListed).GetField("playerAvatar", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field2 == null)
					{
						continue;
					}
					object? value = field2.GetValue(component);
					PlayerAvatar val = (PlayerAvatar)((value is PlayerAvatar) ? value : null);
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.photonView == (Object)null))
					{
						FieldInfo field3 = typeof(PlayerAvatar).GetField("steamID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						string key = ((field3 != null) ? ((field3.GetValue(val) as string) ?? "0") : "0");
						string value2;
						bool num = PlayerVersions.TryGetValue(key, out value2);
						string text = (num ? ("Crowd Control v" + value2) : "Crowd Control Not Found");
						string text2 = ((num && value2 == "1.0.6.0") ? "00FF00" : "FF0000");
						text = "<color=#" + text2 + ">" + text + "</color>";
						FieldInfo field4 = typeof(PlayerAvatar).GetField("playerName", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						string text3 = ((field4 != null) ? ((field4.GetValue(val) as string) ?? "Unknown Player") : "Unknown Player");
						if (val.photonView.Owner == PhotonNetwork.MasterClient)
						{
							((TMP_Text)component.playerName).text = text3 + " <color=#331100>[HOST]</color>\n<color=#00FF00><size=50%>CrowdControl v1.0.6.0</size></color>";
						}
						else
						{
							((TMP_Text)component.playerName).text = text3 + "\n<size=50%>" + text + "</size>";
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController))]
		internal class PlayerStaminaPatch
		{
			[HarmonyPatch("Update")]
			[HarmonyPatch("FixedUpdate")]
			[HarmonyPostfix]
			private static void InfiniteStaminaPatch(PlayerController __instance)
			{
				if (__instance.sprinting && infiniteStamina)
				{
					__instance.EnergyCurrent = __instance.EnergyStart;
				}
				else if (__instance.Sliding && infiniteStamina)
				{
					__instance.EnergyCurrent = __instance.EnergyStart;
				}
			}
		}

		private const string modGUID = "WarpWorld.CrowdControl";

		private const string modName = "Crowd Control";

		public const string modVersion = "1.0.6.0";

		private readonly Harmony harmony = new Harmony("WarpWorld.CrowdControl");

		public static ManualLogSource mls;

		internal static CrowdControlMod Instance = null;

		private ControlClient client;

		public static bool isFocused = true;

		public static bool modActivated = false;

		public static bool infiniteHealth = false;

		public static bool infiniteStamina = false;

		public static Dictionary<string, string> PlayerVersions = new Dictionary<string, string>();

		public static Queue<Action> ActionQueue = new Queue<Action>();

		private void Awake()
		{
			Instance = this;
			mls = Logger.CreateLogSource("Crowd Control");
			mls.LogInfo((object)"Loaded WarpWorld.CrowdControl. Patching.");
			harmony.PatchAll(typeof(CrowdControlMod));
			harmony.PatchAll();
			mls.LogInfo((object)"Initializing Crowd Control");
			string? directoryName = Path.GetDirectoryName(typeof(CrowdControlMod).Assembly.Location);
			string text = Path.Combine(directoryName, "food");
			Path.Combine(directoryName, "warpworld.hypetrain");
			AssetBundle val = AssetBundle.LoadFromFile(text);
			if ((Object)(object)val == (Object)null)
			{
				mls.LogError((object)("Failed to load AssetBundle from " + text));
			}
			if ((Object)(object)val != (Object)null)
			{
				string text2 = "assets/carton of milk 4k pbr/prefab/breadgroup.prefab";
				string text3 = "assets/carton of milk 4k pbr/prefab/milkgroup.prefab";
				GameObject val2 = val.LoadAsset<GameObject>(text2);
				if ((Object)(object)val2 == (Object)null)
				{
					mls.LogError((object)$"Failed to load '{text2}' from asset bundle {val}");
				}
				GameObject val3 = val.LoadAsset<GameObject>(text3);
				if ((Object)(object)val3 == (Object)null)
				{
					mls.LogError((object)$"Failed to load '{text3}' from asset bundle {val}");
				}
				if ((Object)(object)val2 != (Object)null)
				{
					Valuables.RegisterValuable(val2);
				}
				if ((Object)(object)val3 != (Object)null)
				{
					Valuables.RegisterValuable(val3);
				}
			}
			try
			{
				client = new ControlClient();
				new Thread(client.NetworkLoop).Start();
				new Thread(client.RequestLoop).Start();
			}
			catch (Exception ex)
			{
				mls.LogInfo((object)("CC Init Error: " + ex.ToString()));
			}
			mls.LogInfo((object)"Crowd Control Initialized");
			mls = ((BaseUnityPlugin)this).Logger;
		}

		[HarmonyPatch(typeof(PunManager), "Update")]
		[HarmonyPrefix]
		private static void RunEffects()
		{
			while (ActionQueue.Count > 0)
			{
				ActionQueue.Dequeue()();
			}
			lock (TimedThread.threads)
			{
				foreach (TimedThread thread in TimedThread.threads)
				{
					if (!thread.paused)
					{
						thread.effect.tick();
					}
				}
			}
		}
	}
	public class ControlClient
	{
		public static readonly string CV_HOST = "127.0.0.1";

		public static readonly int CV_PORT = 51337;

		private bool paused;

		public static bool connected = false;

		public static bool setName = false;

		public static bool resetName = false;

		public static bool disableLogging = true;

		public bool inGame = true;

		public bool questMessage;

		public static string currentLevel = "";

		private Dictionary<string, CrowdDelegate> Delegate { get; set; }

		private IPEndPoint Endpoint { get; set; }

		private Queue<CrowdRequest> Requests { get; set; }

		private bool Running { get; set; }

		public static Socket Socket { get; set; }

		public ControlClient()
		{
			Endpoint = new IPEndPoint(IPAddress.Parse(CV_HOST), CV_PORT);
			Requests = new Queue<CrowdRequest>();
			Running = true;
			Socket = null;
			Delegate = new Dictionary<string, CrowdDelegate>
			{
				{
					"player_invincible",
					(ControlClient client, CrowdRequest req) => new PlayerInvincibleEffect(client, req).Execute()
				},
				{
					"player_infinitestam",
					(ControlClient client, CrowdRequest req) => new PlayerInfiniteStaminaEffect(client, req).Execute()
				},
				{
					"player_antigravity",
					(ControlClient client, CrowdRequest req) => new PlayerAntiGravityEffect(client, req).Execute()
				},
				{
					"player_disablecrouch",
					(ControlClient client, CrowdRequest req) => new PlayerDisableCrouchEffect(client, req).Execute()
				},
				{
					"player_disableinput",
					(ControlClient client, CrowdRequest req) => new PlayerDisableInputEffect(client, req).Execute()
				},
				{
					"player_feather",
					(ControlClient client, CrowdRequest req) => new PlayerFeatherEffect(client, req).Execute()
				},
				{
					"player_fast",
					(ControlClient client, CrowdRequest req) => new PlayerSpeedEffect(client, req).Execute()
				},
				{
					"player_drain_energy",
					(ControlClient client, CrowdRequest req) => new PlayerDrainEnergyEffect(client, req).Execute()
				},
				{
					"player_refill_energy",
					(ControlClient client, CrowdRequest req) => new PlayerRefillEnergyEffect(client, req).Execute()
				},
				{
					"player_heal",
					(ControlClient client, CrowdRequest req) => new PlayerHealEffect(client, req).Execute()
				},
				{
					"player_hurt",
					(ControlClient client, CrowdRequest req) => new PlayerHurtEffect(client, req).Execute()
				},
				{
					"player_revive",
					(ControlClient client, CrowdRequest req) => new PlayerReviveEffect(client, req).Execute()
				},
				{
					"praise_crowd_control",
					(ControlClient client, CrowdRequest req) => new PraiseCrowdControlEffect(client, req).Execute()
				},
				{
					"player_teleport",
					(ControlClient client, CrowdRequest req) => new PlayerTeleportEffect(client, req).Execute()
				},
				{
					"player_teleport_extraction",
					(ControlClient client, CrowdRequest req) => new PlayerTeleportToExtractionEffect(client, req).Execute()
				},
				{
					"destroy_random_item",
					(ControlClient client, CrowdRequest req) => new DamageRandomValuableEffect(client, req).Execute()
				},
				{
					"player_heal_random",
					(ControlClient client, CrowdRequest req) => new PlayerHealEffect(client, req).Execute()
				},
				{
					"spawncollectablerandom_ItemCartMedium",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"increase_loot_goal",
					(ControlClient client, CrowdRequest req) => new UpdateHaulGoalEffect(client, req).Execute()
				},
				{
					"decrease_loot_goal",
					(ControlClient client, CrowdRequest req) => new UpdateHaulGoalEffect(client, req).Execute()
				},
				{
					"playerupgrade_energy",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_health",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_map",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_jump",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_grabrange",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_grabstrength",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_sprint",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_throw",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"playerupgrade_tumble",
					(ControlClient client, CrowdRequest req) => new UpgradePlayerEffect(client, req).Execute()
				},
				{
					"killplayer",
					(ControlClient client, CrowdRequest req) => new PlayerKillEffect(client, req).Execute()
				},
				{
					"spawnenemy",
					(ControlClient client, CrowdRequest req) => new SpawnEnemyEffect(client, req).Execute()
				},
				{
					"spawncustom_Bread",
					(ControlClient client, CrowdRequest req) => new SpawnCustomItemEffect(client, req).Execute()
				},
				{
					"spawncustom_Milk",
					(ControlClient client, CrowdRequest req) => new SpawnCustomItemEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemCartMedium",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemCartSmall",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemDroneBattery",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemDroneFeather",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemDroneIndestructible",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemDroneTorque",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemDroneZeroGravity",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemExtractionTracker",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGrenadeDuctTaped",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGrenadeExplosive",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGrenadeHuman",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGrenadeShockwave",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGrenadeStun",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGunHandgun",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGunShotgun",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemGunTranq",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemHealthPackLarge",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemHealthPackMedium",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemHealthPackSmall",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMeleeBaseballBat",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMeleeFryingPan",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMeleeInflatableHammer",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMeleeSledgeHammer",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMeleeSword",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMineExplosive",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMineShockwave",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemMineStun",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemOrbZeroGravity",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemPowerCrystal",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemRubberDuck",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradeMapPlayerCount",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerEnergy",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerExtraJump",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerGrabRange",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerGrabStrength",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerGrabThrow",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerHealth",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerSprintSpeed",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemUpgradePlayerTumbleLaunch",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ItemValuableTracker",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableDiamond",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableEmeraldBracelet",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGoblet",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableOcarina",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuablePocketWatch",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableUraniumMug",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticBonsai",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticHDD",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableChompBook",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableCrown",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableDoll",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableFrog",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGemBox",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGlobe",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableLovePotion",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableMoney",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableMusicBox",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableToyMonkey",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableUraniumPlate",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableVaseSmall",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArctic3DPrinter",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticLaptop",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticPropaneTank",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticSampleSixPack",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticSample",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableBottle",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableClown",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableComputer",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableFan",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGramophone",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableMarbleTable",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableRadio",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableShipInBottle",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableTrophy",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableVase",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardGoblinHead",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardPowerCrystal",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardTimeGlass",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticBarrel",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticBigSample",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticCreatureLeg",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticFlamethrower",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticGuitar",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticSampleCooler",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableDiamondDisplay",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableIceSaw",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableScreamDoll",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableTelevision",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableVaseBig",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardCubeOfKnowledge",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardMasterPotion",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableAnimalCrate",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticIceBlock",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableDinosaur",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuablePiano",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardGriffinStatue",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticScienceStation",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableHarp",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuablePainting",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardDumgolfsStaff",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardSword",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableArcticServerRack",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGoldenStatue",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableGrandfatherClock",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				},
				{
					"spawncollectable_ValuableWizardBroom",
					(ControlClient client, CrowdRequest req) => new SpawnCollectableEffect(client, req).Execute()
				}
			};
		}

		public static bool IsExcludedLevel(Level currentLevel)
		{
			return new HashSet<Level>
			{
				RunManager.instance.levelShop,
				RunManager.instance.levelLobby,
				RunManager.instance.levelArena,
				RunManager.instance.levelTutorial,
				RunManager.instance.levelLobbyMenu,
				RunManager.instance.levelMainMenu,
				RunManager.instance.levelRecording
			}.Contains(currentLevel);
		}

		public static (bool status, string? message) IsReady()
		{
			if (!Object.op_Implicit((Object)(object)RunManager.instance))
			{
				return (false, "Game is not ready.");
			}
			if (currentLevel != ((object)RunManager.instance.levelCurrent).ToString() && !CrowdControlMod.modActivated)
			{
				RPCCommands.MessageHandler.SendMessageToHost("CC_CONNECT", 0, PhotonNetwork.LocalPlayer.ActorNumber, 0, new Dictionary<string, object> { { "version", "1.0.6.0" } });
			}
			currentLevel = ((object)RunManager.instance.levelCurrent).ToString();
			if (IsExcludedLevel(RunManager.instance.levelCurrent))
			{
				return (false, "Not in supported level.");
			}
			if (!CrowdControlMod.modActivated)
			{
				return (false, "Version does not match host.");
			}
			TruckScreenText instance = TruckScreenText.instance;
			FieldInfo field = typeof(TruckScreenText).GetField("started", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field == null)
			{
				return (false, null);
			}
			if (!(bool)field.GetValue(instance))
			{
				return (false, "");
			}
			if (!disableLogging)
			{
				CrowdControlMod.mls.LogInfo((object)"Success: All checks passed");
			}
			return (true, "");
		}

		public static void HideEffect(string code)
		{
			CrowdResponse crowdResponse = new CrowdResponse(0, CrowdResponse.Status.STATUS_NOTVISIBLE);
			crowdResponse.type = 1;
			crowdResponse.code = code;
			crowdResponse.Send(Socket);
		}

		public static void ShowEffect(string code)
		{
			CrowdResponse crowdResponse = new CrowdResponse(0, CrowdResponse.Status.STATUS_VISIBLE);
			crowdResponse.type = 1;
			crowdResponse.code = code;
			crowdResponse.Send(Socket);
		}

		public static void DisableEffect(string code)
		{
			CrowdResponse crowdResponse = new CrowdResponse(0, CrowdResponse.Status.STATUS_NOTSELECTABLE);
			crowdResponse.type = 1;
			crowdResponse.code = code;
			crowdResponse.Send(Socket);
		}

		public static void EnableEffect(string code)
		{
			CrowdResponse crowdResponse = new CrowdResponse(0, CrowdResponse.Status.STATUS_SELECTABLE);
			crowdResponse.type = 1;
			crowdResponse.code = code;
			crowdResponse.Send(Socket);
		}

		private void ClientLoop()
		{
			CrowdControlMod.mls.LogInfo((object)"Connected to Crowd Control");
			Timer timer = new Timer(timeUpdate, null, 0, 200);
			try
			{
				while (Running)
				{
					try
					{
						if (Socket == null || !Socket.Connected)
						{
							break;
						}
						connected = true;
						CrowdRequest crowdRequest = CrowdRequest.Recieve(this, Socket);
						if (crowdRequest != null && !crowdRequest.IsKeepAlive())
						{
							lock (Requests)
							{
								Requests.Enqueue(crowdRequest);
							}
						}
						continue;
					}
					catch (ObjectDisposedException)
					{
						break;
					}
					catch (SocketException)
					{
						break;
					}
					catch (ThreadAbortException)
					{
						Thread.ResetAbort();
						break;
					}
					catch (Exception)
					{
					}
				}
			}
			catch (Exception arg)
			{
				CrowdControlMod.mls.LogInfo((object)$"Critical Error: {arg}");
			}
			finally
			{
				CrowdControlMod.mls.LogInfo((object)"Disconnected from Crowd Control.");
				connected = false;
				try
				{
					if (Socket != null)
					{
						Socket.Dispose();
					}
					timer.Dispose();
				}
				catch (Exception)
				{
				}
			}
		}

		public void timeUpdate(object state)
		{
			inGame = true;
			if (!IsReady().status)
			{
				inGame = false;
			}
			if (!inGame)
			{
				TimedThread.addTime(200);
				paused = true;
			}
			else if (paused)
			{
				paused = false;
				TimedThread.unPause();
				TimedThread.tickTime(200);
			}
			else
			{
				TimedThread.tickTime(200);
			}
		}

		public bool IsRunning()
		{
			return Running;
		}

		public void NetworkLoop()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			while (Running)
			{
				CrowdControlMod.mls.LogInfo((object)"Attempting to connect to Crowd Control");
				connected = false;
				try
				{
					Socket = new Socket(Endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
					Socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, optionValue: true);
					if (Socket.BeginConnect(Endpoint, null, null).AsyncWaitHandle.WaitOne(10000, exitContext: true) && Socket.Connected)
					{
						ClientLoop();
					}
					else
					{
						CrowdControlMod.mls.LogInfo((object)"Failed to connect to Crowd Control");
						connected = false;
					}
					Socket.Close();
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogInfo((object)ex.GetType().Name);
					CrowdControlMod.mls.LogInfo((object)"Failed to connect to Crowd Control");
					connected = false;
				}
				Thread.Sleep(10000);
			}
		}

		public void RequestLoop()
		{
			Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
			while (Running)
			{
				try
				{
					CrowdRequest crowdRequest = null;
					lock (Requests)
					{
						if (Requests.Count == 0)
						{
							continue;
						}
						crowdRequest = Requests.Dequeue();
						goto IL_0052;
					}
					IL_0052:
					string reqCode = crowdRequest.GetReqCode();
					try
					{
						(bool status, string? message) tuple = IsReady();
						bool item = tuple.status;
						string item2 = tuple.message;
						CrowdResponse crowdResponse = (item ? Delegate[reqCode](this, crowdRequest) : new CrowdResponse(crowdRequest.GetReqID(), (!(item2 == "")) ? CrowdResponse.Status.STATUS_FAILURE : CrowdResponse.Status.STATUS_RETRY, item2));
						if (crowdResponse == null)
						{
							new CrowdResponse(crowdRequest.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Request error for '" + reqCode + "'").Send(Socket);
						}
						crowdResponse.Send(Socket);
					}
					catch (KeyNotFoundException)
					{
						new CrowdResponse(crowdRequest.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Request error for '" + reqCode + "'").Send(Socket);
					}
				}
				catch (Exception)
				{
					CrowdControlMod.mls.LogInfo((object)"Disconnected from Crowd Control.");
					connected = false;
					Socket.Close();
				}
			}
		}

		public void Stop()
		{
			Running = false;
		}
	}
	public delegate CrowdResponse CrowdDelegate(ControlClient client, CrowdRequest req);
	public class CrowdDelegates
	{
		public static Random rnd = new Random();

		public static readonly TimeSpan SERVER_TIMEOUT = TimeSpan.FromSeconds(5.0);

		public static void setProperty(object a, string prop, object val)
		{
			PropertyInfo property = a.GetType().GetProperty(prop, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanWrite)
			{
				property.SetValue(a, val);
			}
		}

		public static object getProperty(object a, string prop)
		{
			return a.GetType().GetField(prop, BindingFlags.Instance | BindingFlags.NonPublic).GetValue(a);
		}

		public static void setSubProperty(object a, string prop, string prop2, object val)
		{
			FieldInfo field = a.GetType().GetField(prop, BindingFlags.Instance | BindingFlags.NonPublic);
			field.GetType().GetField(prop, BindingFlags.Instance | BindingFlags.NonPublic).SetValue(field, val);
		}

		public static void callSubFunc(object a, string prop, string func, object val)
		{
			callSubFunc(a, prop, func, new object[1] { val });
		}

		public static void callSubFunc(object a, string prop, string func, object[] vals)
		{
			FieldInfo field = a.GetType().GetField(prop, BindingFlags.Instance | BindingFlags.NonPublic);
			field.GetType().GetMethod(func, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy).Invoke(field, vals);
		}

		public static void callFunc(object a, string func, object val)
		{
			callFunc(a, func, new object[1] { val });
		}

		public static void callFunc(object a, string func, object[] vals)
		{
			a.GetType().GetMethod(func, BindingFlags.Instance | BindingFlags.NonPublic).Invoke(a, vals);
		}

		public static object callAndReturnFunc(object a, string func, object val)
		{
			return callAndReturnFunc(a, func, new object[1] { val });
		}

		public static object callAndReturnFunc(object a, string func, object[] vals)
		{
			return a.GetType().GetMethod(func, BindingFlags.Instance | BindingFlags.NonPublic).Invoke(a, vals);
		}
	}
	public class CrowdRequest
	{
		public enum Type
		{
			REQUEST_TEST = 0,
			REQUEST_START = 1,
			REQUEST_STOP = 2,
			REQUEST_KEEPALIVE = 255
		}

		public class Target
		{
			public string service;

			public string id;

			public string name;

			public string avatar;
		}

		public class SourceDetails
		{
			public class Contribution
			{
				public string user_id;

				public string user_login;

				public string user_name;

				public string type;

				public int total;
			}

			public int total;

			public int progress;

			public int goal;

			public Contribution[] top_contributions;

			public Contribution last_contribution;

			public int level;
		}

		public static readonly int RECV_BUF = 4096;

		public static readonly int RECV_TIME = 5000000;

		public string code;

		public int id;

		public int duration;

		public string type;

		public string viewer;

		public Target[] targets;

		public SourceDetails sourceDetails;

		public static CrowdRequest Recieve(ControlClient client, Socket socket)
		{
			byte[] array = new byte[RECV_BUF];
			string text = "";
			int num = 0;
			do
			{
				if (!client.IsRunning())
				{
					return null;
				}
				if (socket.Poll(RECV_TIME, SelectMode.SelectRead))
				{
					num = socket.Receive(array);
					if (num < 0)
					{
						return null;
					}
					text += Encoding.ASCII.GetString(array);
				}
				else
				{
					CrowdResponse.KeepAlive(socket);
				}
			}
			while (num == 0 || (num == RECV_BUF && array[RECV_BUF - 1] != 0));
			return JsonConvert.DeserializeObject<CrowdRequest>(text);
		}

		public string GetReqCode()
		{
			return code;
		}

		public int GetReqID()
		{
			return id;
		}

		public int GetReqDuration()
		{
			return duration;
		}

		public Type GetReqType()
		{
			string text = type;
			if (text == "1")
			{
				return Type.REQUEST_START;
			}
			if (text == "2")
			{
				return Type.REQUEST_STOP;
			}
			return Type.REQUEST_TEST;
		}

		public string GetReqViewer()
		{
			return viewer;
		}

		public bool IsKeepAlive()
		{
			if (id == 0)
			{
				return type == "255";
			}
			return false;
		}
	}
	public class CrowdResponse
	{
		public enum Status
		{
			STATUS_SUCCESS = 0,
			STATUS_FAILURE = 1,
			STATUS_UNAVAIL = 2,
			STATUS_RETRY = 3,
			STATUS_START = 5,
			STATUS_PAUSE = 6,
			STATUS_RESUME = 7,
			STATUS_STOP = 8,
			STATUS_VISIBLE = 128,
			STATUS_NOTVISIBLE = 129,
			STATUS_SELECTABLE = 130,
			STATUS_NOTSELECTABLE = 131,
			STATUS_KEEPALIVE = 255
		}

		public int id;

		public string message;

		public string code;

		public int status;

		public int type;

		public CrowdResponse(int id, Status status = Status.STATUS_SUCCESS, string message = "")
		{
			type = 0;
			code = "";
			this.id = id;
			this.message = message;
			this.status = (int)status;
		}

		public static void KeepAlive(Socket socket)
		{
			new CrowdResponse(0, Status.STATUS_KEEPALIVE).Send(socket);
		}

		public void Send(Socket socket)
		{
			byte[] bytes = Encoding.ASCII.GetBytes(JsonConvert.SerializeObject((object)this));
			byte[] array = new byte[bytes.Length + 1];
			Buffer.BlockCopy(bytes, 0, array, 0, bytes.Length);
			array[bytes.Length] = 0;
			socket.Send(array);
		}
	}
	public class RPCCommands
	{
		[HarmonyPatch(typeof(NetworkManager))]
		[HarmonyPatch("Start")]
		public class NetworkManagerPatch
		{
			public static void Postfix()
			{
				MessageHandler.Initialize();
			}
		}

		public class MessageHandler : MonoBehaviourPunCallbacks, IPunObservable
		{
			public class NetworkMessage
			{
				public string type;

				public int id;

				public int targetActor;

				public int senderID;

				public Dictionary<string, object> payload;

				public NetworkMessage(string type, int id = 0, int senderID = 0, int targetActor = 0, Dictionary<string, object> payload = null)
				{
					this.type = type;
					this.payload = payload ?? new Dictionary<string, object>();
					this.id = id;
					this.senderID = senderID;
					this.targetActor = targetActor;
				}
			}

			private class RequestMessage
			{
				public string type { get; set; }

				public Dictionary<string, object> payload { get; set; }

				public int id { get; set; }

				public int senderID { get; set; }

				public int targetActor { get; set; }

				public bool random { get; set; }
			}

			private class ResponseMessage
			{
				public string type { get; set; } = "response";


				public int id { get; set; }

				public int senderID { get; set; }

				public int targetActor { get; set; }

				public string status { get; set; }

				public string message { get; set; }

				public string version { get; set; }

				public Dictionary<string, object> payload { get; set; }
			}

			[CompilerGenerated]
			private sealed class <SendDelayedResponse>d__15 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private object <>2__current;

				public int id;

				public int senderID;

				public bool success;

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

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

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

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

				private bool MoveNext()
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0027: Expected O, but got Unknown
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 1;
						return true;
					case 1:
						<>1__state = -1;
						SendResponse(id, senderID, (!success) ? CrowdResponse.Status.STATUS_FAILURE : CrowdResponse.Status.STATUS_SUCCESS);
						return false;
					}
				}

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

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

			public static MessageHandler instance;

			public static PhotonView networkView;

			private static ConcurrentQueue<NetworkMessage> messageQueue = new ConcurrentQueue<NetworkMessage>();

			public static void Initialize()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if ((Object)(object)instance != (Object)null)
					{
						return;
					}
					CrowdControlMod.mls.LogInfo((object)"Initializing MessageHandler...");
					GameObject val = new GameObject("MessageHandler");
					instance = val.AddComponent<MessageHandler>();
					networkView = val.AddComponent<PhotonView>();
					if ((Object)(object)networkView != (Object)null)
					{
						networkView.ViewID = 6767;
						networkView.Synchronization = (ViewSynchronization)3;
						networkView.ObservedComponents = new List<Component> { (Component)(object)instance };
						CrowdControlMod.mls.LogInfo((object)$"MessageHandler initialized with PhotonView {networkView.ViewID}");
						Object.DontDestroyOnLoad((Object)(object)val);
						lock (networkLock)
						{
							_isNetworkReady = null;
							_isViewValid = null;
							return;
						}
					}
					CrowdControlMod.mls.LogError((object)"Failed to add PhotonView to MessageHandler");
					CrowdControlMod.modActivated = false;
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogError((object)("Error in Initialize: " + ex.Message));
					CrowdControlMod.mls.LogError((object)("Stack trace: " + ex.StackTrace));
				}
			}

			private void OnLevelWasLoaded(int level)
			{
				lock (networkLock)
				{
					_isNetworkReady = null;
					_isViewValid = null;
				}
				if ((Object)(object)networkView == (Object)null || !networkView.ViewID.Equals(6767))
				{
					Initialize();
				}
			}

			private void Update()
			{
				if (messageQueue.TryDequeue(out var result))
				{
					SendQueuedMessage(result);
				}
			}

			private static void SendQueuedMessage(NetworkMessage message)
			{
				if (IsNetworkReady())
				{
					try
					{
						string text = JsonConvert.SerializeObject((object)message);
						networkView.RPC("OnNetworkMessageRPC", (RpcTarget)0, new object[1] { text });
					}
					catch (Exception ex)
					{
						CrowdControlMod.mls.LogError((object)("Failed to send message: " + ex.Message));
						CrowdControlMod.mls.LogError((object)("Stack trace: " + ex.StackTrace));
					}
				}
			}

			public static void SendMessageToHost(string type, int id = 0, int senderID = 0, int targetActor = 0, Dictionary<string, object> payload = null)
			{
				try
				{
					if (!IsNetworkReady())
					{
						return;
					}
					NetworkMessage item = new NetworkMessage(type, id, senderID, targetActor, payload);
					if (id > 0)
					{
						lock (pendingRequestIDs)
						{
							pendingRequestIDs.Add(id.ToString());
						}
					}
					messageQueue.Enqueue(item);
				}
				catch (Exception arg)
				{
					CrowdControlMod.mls.LogInfo((object)$"Failed to queue message: {arg}");
				}
			}

			public override void OnEnable()
			{
				((MonoBehaviourPunCallbacks)this).OnEnable();
			}

			public override void OnJoinedRoom()
			{
				((MonoBehaviourPunCallbacks)this).OnJoinedRoom();
				lock (networkLock)
				{
					_isNetworkReady = null;
					_isViewValid = null;
				}
				CrowdControlMod.modActivated = false;
				if (PhotonNetwork.IsMasterClient)
				{
					CrowdControlMod.modActivated = true;
				}
			}

			[PunRPC]
			public void OnNetworkMessageRPC(string jsonMessage)
			{
				try
				{
					NetworkMessage networkMessage = JsonConvert.DeserializeObject<NetworkMessage>(jsonMessage);
					if (networkMessage == null)
					{
						CrowdControlMod.mls.LogError((object)"Failed to deserialize message");
					}
					else if (networkMessage.type == "response")
					{
						ProcessMessage(jsonMessage);
					}
					else if (networkMessage.type == "CC_CONNECT")
					{
						ModVersionCheck(networkMessage);
					}
					else if (PhotonNetwork.IsMasterClient)
					{
						switch (networkMessage.type)
						{
						case "spawn_collectable":
							SpawnCollectableEffect.Trigger(networkMessage);
							break;
						case "spawn_custom":
							SpawnCustomItemEffect.Trigger(networkMessage);
							break;
						case "player_heal":
							PlayerHealEffect.Trigger(networkMessage);
							break;
						case "player_hurt":
							PlayerHurtEffect.Trigger(networkMessage);
							break;
						case "player_revive":
							PlayerReviveEffect.Trigger(networkMessage);
							break;
						case "destroy_random_item":
							DamageRandomValuableEffect.Trigger(networkMessage);
							break;
						case "update_haul":
							UpdateHaulGoalEffect.Trigger(networkMessage);
							break;
						case "upgrade_player":
							UpgradePlayerEffect.Trigger(networkMessage);
							break;
						case "spawn_enemy":
							SpawnEnemyEffect.Trigger(networkMessage);
							break;
						default:
							CrowdControlMod.mls.LogWarning((object)("Unknown message type: " + networkMessage.type));
							break;
						}
					}
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogError((object)("Failed to process message: " + ex.Message));
					CrowdControlMod.mls.LogError((object)("Stack trace: " + ex.StackTrace));
				}
			}

			public void OnPhotonSerializeView(PhotonStream stream, PhotonMessageInfo info)
			{
			}

			public static async Task ModVersionCheck(NetworkMessage message)
			{
				string version = Convert.ToString(message.payload["version"]);
				PlayerAvatar obj = await HelperUtils.FindPlayerAvatarByNumber(message.senderID);
				FieldInfo field = typeof(PlayerAvatar).GetField("steamID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				string key = ((field != null) ? ((field.GetValue(obj) as string) ?? "0") : "0");
				CrowdControlMod.PlayerVersions[key] = version;
				if (PhotonNetwork.IsMasterClient)
				{
					SendResponse(0, message.senderID, CrowdResponse.Status.STATUS_SUCCESS, "", new Dictionary<string, object> { { "version", "1.0.6.0" } });
				}
			}

			public static void SendResponse(int id, int senderID, CrowdResponse.Status status, string message = "", Dictionary<string, object> payload = null)
			{
				try
				{
					int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
					Dictionary<string, object> dictionary = new Dictionary<string, object>
					{
						{
							"status",
							status.ToString()
						},
						{
							"message",
							message.ToString()
						},
						{ "cmd", "response" }
					};
					if (payload != null && payload.ContainsKey("version") && payload["version"] != null)
					{
						dictionary["version"] = payload["version"].ToString();
					}
					string text = JsonConvert.SerializeObject((object)new NetworkMessage("response", id, senderID, actorNumber, dictionary));
					networkView.RPC("OnNetworkMessageRPC", (RpcTarget)0, new object[1] { text });
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogInfo((object)("SEND RESPONSE CRASHED " + ex));
				}
			}

			[IteratorStateMachine(typeof(<SendDelayedResponse>d__15))]
			private IEnumerator SendDelayedResponse(int id, int senderID, bool success)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <SendDelayedResponse>d__15(0)
				{
					id = id,
					senderID = senderID,
					success = success
				};
			}

			public static bool IsHost()
			{
				return PhotonNetwork.IsMasterClient;
			}

			public static void SendRequest(string type, int id, int senderID, int targetActor, Dictionary<string, object> payload)
			{
				try
				{
					string text = JsonConvert.SerializeObject((object)new RequestMessage
					{
						type = type,
						id = id,
						senderID = senderID,
						targetActor = targetActor,
						payload = payload
					}, jsonSettings);
					if ((Object)(object)networkView != (Object)null)
					{
						pendingRequestIDs.Add(id.ToString());
						networkView.RPC("OnNetworkMessageRPC", (RpcTarget)2, new object[1] { text });
					}
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogInfo((object)("SEND REQUEST " + ex));
				}
			}

			public static void SendResponse(int id, int senderID, CrowdResponse.Status status, Dictionary<string, object> payload)
			{
				try
				{
					string text = JsonConvert.SerializeObject((object)new ResponseMessage
					{
						id = id,
						senderID = senderID,
						status = status.ToString(),
						payload = payload
					}, jsonSettings);
					if ((Object)(object)networkView != (Object)null)
					{
						networkView.RPC("OnNetworkMessageRPC", (RpcTarget)0, new object[1] { text });
					}
				}
				catch (Exception ex)
				{
					CrowdControlMod.mls.LogInfo((object)("SEND RESPONSE2 " + ex));
				}
			}

			public static void AddResponder(int msgID, Action<CrowdResponse.Status> responder)
			{
				rspResponders[msgID] = responder;
			}

			public static void RemoveResponder(int msgID)
			{
				rspResponders.TryRemove(msgID, out var _);
			}

			public static void ProcessMessage(string message)
			{
				try
				{
					if (string.IsNullOrEmpty(message))
					{
						return;
					}
					JObject val = JObject.Parse(message);
					if (val == null)
					{
						CrowdControlMod.mls.LogWarning((object)("Received malformed message: " + message));
						return;
					}
					if (((object)val["type"])?.ToString() == "response")
					{
						ResponseMessage responseMessage = new ResponseMessage();
						JToken obj = val["id"];
						responseMessage.id = ((obj != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj) : 0);
						JToken obj2 = val["senderID"];
						responseMessage.senderID = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : 0);
						JToken obj3 = val["targetActor"];
						responseMessage.targetActor = ((obj3 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj3) : 0);
						JToken obj4 = val["payload"];
						responseMessage.payload = ((obj4 != null) ? obj4.ToObject<Dictionary<string, object>>() : null) ?? new Dictionary<string, object>();
						JToken obj5 = val["payload"];
						responseMessage.status = ((obj5 == null) ? null : ((object)obj5[(object)"status"])?.ToString());
						JToken obj6 = val["payload"];
						responseMessage.version = ((obj6 == null) ? null : ((object)obj6[(object)"version"])?.ToString());
						ProcessResponse(responseMessage);
						return;
					}
					try
					{
						JsonConvert.DeserializeObject<RequestMessage>(message, jsonSettings);
					}
					catch (Exception ex)
					{
						CrowdControlMod.mls.LogError((object)("Error processing message2: " + ex.Message));
					}
				}
				catch (Exception ex2)
				{
					CrowdControlMod.mls.LogError((object)("Error processing message: " + ex2.Message));
					CrowdControlMod.mls.LogError((object)("Stack trace: " + ex2.StackTrace));
				}
			}

			private static void ProcessResponse(ResponseMessage message)
			{
				if (message.senderID != PhotonNetwork.LocalPlayer.ActorNumber)
				{
					return;
				}
				if (message.id == 0 && message.version == "1.0.6.0")
				{
					CrowdControlMod.modActivated = true;
				}
				if (!rspResponders.TryGetValue(message.id, out var value) || !pendingRequestIDs.Remove(message.id.ToString()) || !Enum.TryParse<CrowdResponse.Status>(message.status, out var result))
				{
					return;
				}
				try
				{
					value(result);
				}
				catch (Exception arg)
				{
					CrowdControlMod.mls.LogInfo((object)$"Error processing response for message ID {message.id}: {arg}");
				}
			}
		}

		internal static HashSet<string> pendingRequestIDs = new HashSet<string>();

		private static readonly ConcurrentDictionary<int, Action<CrowdResponse.Status>> rspResponders = new ConcurrentDictionary<int, Action<CrowdResponse.Status>>();

		private static readonly JsonSerializerSettings jsonSettings = new JsonSerializerSettings
		{
			NullValueHandling = (NullValueHandling)1,
			ReferenceLoopHandling = (ReferenceLoopHandling)1
		};

		private static readonly object networkLock = new object();

		private static bool? _isNetworkReady = null;

		private static bool? _isViewValid = null;

		private static bool IsViewValid()
		{
			lock (networkLock)
			{
				if (_isViewValid.HasValue)
				{
					return _isViewValid.Value;
				}
				PhotonView networkView = MessageHandler.networkView;
				if ((Object)(object)networkView == (Object)null)
				{
					_isViewValid = false;
					CrowdControlMod.mls.LogWarning((object)"NetworkView is null");
					return false;
				}
				_isViewValid = networkView.ViewID != 0;
				return _isViewValid.Value;
			}
		}

		private static bool IsNetworkReady()
		{
			lock (networkLock)
			{
				if (_isNetworkReady.HasValue)
				{
					return _isNetworkReady.Value;
				}
				bool flag = IsViewValid();
				_isNetworkReady = PhotonNetwork.IsConnected && PhotonNetwork.InRoom && flag && MessageHandler.networkView.ObservedComponents != null;
				return _isNetworkReady.Value;
			}
		}
	}
	public class TimedResponse : CrowdResponse
	{
		public int timeRemaining;

		public TimedResponse(int id, int dur, Status status = Status.STATUS_SUCCESS, string message = "")
			: base(id, status, message)
		{
			timeRemaining = dur;
		}
	}
}
namespace BepinControl.Effects
{
	public class SpawnCustomItemEffect : BaseEffect
	{
		public SpawnCustomItemEffect(ControlClient client, CrowdRequest request)
			: base(client, request)
		{
		}

		public static async Task Trigger(RPCCommands.MessageHandler.NetworkMessage message)
		{
			_ = 1;
			try
			{
				int targetActor = message.targetActor;
				string item = Convert.ToString(message.payload["item"]);
				PlayerAvatar playerAvatar = await HelperUtils.FindPlayerAvatarByNumber(targetActor);
				if ((Object)(object)playerAvatar == (Object)null)
				{
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE, "Unable to find player.");
					return;
				}
				TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0021: Unknown result type (might be due to invalid IL or missing references)
					//IL_0031: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						SpawnItem(item, ((Component)playerAvatar).transform.position, ((Component)playerAvatar).transform.forward, ((Component)playerAvatar).transform.rotation);
						tcs.TrySetResult(result: true);
					}
					catch (Exception arg2)
					{
						CrowdControlMod.mls.LogInfo((object)$"Failed to spawn item: {arg2}");
						tcs.TrySetResult(result: false);
					}
				});
				bool flag = await tcs.Task;
				RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, (!flag) ? CrowdResponse.Status.STATUS_FAILURE : CrowdResponse.Status.STATUS_SUCCESS);
			}
			catch (Exception arg)
			{
				CrowdControlMod.mls.LogInfo((object)$"Failed to process spawn data: {arg}");
				RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
			}
		}

		public override CrowdResponse Execute()
		{
			CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
			string message = "";
			string item = ((request.code.Split(new char[1] { '_' }).Length > 1) ? request.code.Split(new char[1] { '_' })[1] : string.Empty);
			if (string.IsNullOrEmpty(item))
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Invalid item code");
			}
			request.code.ToLowerInvariant().Contains("random_");
			int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
			PlayerAvatar result = HelperUtils.FindPlayerAvatarByNumber(actorNumber).Result;
			if ((Object)(object)result == (Object)null)
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Cannot Spawn Items when player is dead!");
			}
			PhotonView component = ((Component)result).GetComponent<PhotonView>();
			if ((Object)(object)component == (Object)null)
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Cannot Spawn Items when player is dead!");
			}
			int actorNumber2 = component.Owner.ActorNumber;
			try
			{
				TaskCompletionSource<CrowdResponse.Status> tcs = new TaskCompletionSource<CrowdResponse.Status>();
				RPCCommands.MessageHandler.AddResponder(request.GetReqID(), delegate(CrowdResponse.Status s)
				{
					tcs.SetResult(s);
				});
				RPCCommands.MessageHandler.SendMessageToHost("spawn_custom", request.GetReqID(), actorNumber, actorNumber2, new Dictionary<string, object> { { "item", item } });
				status = (tcs.Task.Wait(CrowdDelegates.SERVER_TIMEOUT) ? tcs.Task.Result : CrowdResponse.Status.STATUS_RETRY);
				RPCCommands.MessageHandler.RemoveResponder(request.GetReqID());
			}
			catch (Exception)
			{
				status = CrowdResponse.Status.STATUS_FAILURE;
				message = "Failed to spawn item";
			}
			if (status == CrowdResponse.Status.STATUS_SUCCESS)
			{
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//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)
					MissionUI instance = Singleton<MissionUI>.Instance;
					if (instance != null)
					{
						instance.MissionText("CC Spawned " + item, Color.green, Color.green, 1f);
					}
				});
			}
			return CreateResponse(status, message);
		}

		public static bool SpawnItem(string item, Vector3 playerPosition, Vector3 playerForward, Quaternion rotation)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			bool success = false;
			CrowdControlMod.ActionQueue.Enqueue(delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: 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_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: 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)
				//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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: 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_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					float num = 1f;
					RaycastHit val = default(RaycastHit);
					if (Physics.Raycast(playerPosition, playerForward, ref val, num + 0.5f))
					{
						num = -1f;
					}
					Vector3 val2 = playerPosition + playerForward * num;
					RaycastHit val3 = default(RaycastHit);
					if (Physics.Raycast(val2 + Vector3.up * 2f, Vector3.down, ref val3, 10f))
					{
						val2 = ((RaycastHit)(ref val3)).point + Vector3.up * 0.1f;
					}
					Quaternion identity = Quaternion.identity;
					GameObject val4 = ((item == "Bread") ? PhotonNetwork.InstantiateRoomObject("BreadGroup", val2, identity, (byte)0, (object[])null) : PhotonNetwork.InstantiateRoomObject("MilkGroup", val2, identity, (byte)0, (object[])null));
					success = (Object)(object)val4 != (Object)null;
				}
				catch (Exception arg)
				{
					CrowdControlMod.mls.LogInfo((object)$"Failed to spawn item: {arg}");
				}
			});
			return success;
		}
	}
	public class SpawnEnemyEffect : BaseEffect
	{
		public SpawnEnemyEffect(ControlClient client, CrowdRequest request)
			: base(client, request)
		{
		}

		public override CrowdResponse Execute()
		{
			request.code.ToLowerInvariant().Contains("random_");
			int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
			PlayerAvatar result = HelperUtils.FindPlayerAvatarByNumber(actorNumber).Result;
			if ((Object)(object)result == (Object)null)
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Cannot Spawn Items when player is dead!");
			}
			int actorNumber2 = ((Component)result).GetComponent<PhotonView>().Owner.ActorNumber;
			try
			{
				TaskCompletionSource<CrowdResponse.Status> tcs = new TaskCompletionSource<CrowdResponse.Status>();
				RPCCommands.MessageHandler.AddResponder(request.id, delegate(CrowdResponse.Status s)
				{
					tcs.SetResult(s);
				});
				RPCCommands.MessageHandler.SendMessageToHost("spawn_enemy", request.id, actorNumber, actorNumber2, new Dictionary<string, object> { { "enemy", "robe" } });
				if (tcs.Task.Wait(CrowdDelegates.SERVER_TIMEOUT))
				{
					CrowdResponse.Status result2 = tcs.Task.Result;
					RPCCommands.MessageHandler.RemoveResponder(request.id);
					return CreateResponse(result2);
				}
				RPCCommands.MessageHandler.RemoveResponder(request.id);
				return CreateResponse(CrowdResponse.Status.STATUS_RETRY);
			}
			catch (Exception)
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Failed to spawn enemy.");
			}
		}

		public static async Task Trigger(RPCCommands.MessageHandler.NetworkMessage message)
		{
			try
			{
				if (message == null)
				{
					CrowdControlMod.mls.LogError((object)"SpawnEnemyEffect: Message is null");
					return;
				}
				PlayerAvatar playerAvatar = await HelperUtils.FindPlayerAvatarByNumber(message.targetActor);
				if ((Object)(object)playerAvatar == (Object)null)
				{
					CrowdControlMod.mls.LogError((object)"SpawnEnemyEffect: Player not found");
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
					return;
				}
				if (!PhotonNetwork.IsConnected || !PhotonNetwork.InRoom)
				{
					CrowdControlMod.mls.LogError((object)"SpawnEnemyEffect: Not connected to network or room");
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
					return;
				}
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_0010: 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_002a: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0034: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Unknown result type (might be due to invalid IL or missing references)
					//IL_0045: 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_004f: 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_0051: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						Vector3 val = ((Component)playerAvatar).transform.position + ((Component)playerAvatar).transform.forward * 2f;
						Quaternion val2 = Quaternion.LookRotation(-((Component)playerAvatar).transform.forward);
						GameObject val3 = PhotonNetwork.InstantiateRoomObject("enemies/Enemy - Robe", val, val2, (byte)0, (object[])null);
						if ((Object)(object)val3 == (Object)null)
						{
							CrowdControlMod.mls.LogError((object)"SpawnEnemyEffect: Failed to instantiate enemy");
							RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
						}
						else
						{
							EnemyParent component = val3.GetComponent<EnemyParent>();
							EnemyRobe component2 = val3.GetComponent<EnemyRobe>();
							PhotonView component3 = val3.GetComponent<PhotonView>();
							if ((Object)(object)component == (Object)null || (Object)(object)component2 == (Object)null || (Object)(object)component3 == (Object)null)
							{
								CrowdControlMod.mls.LogError((object)"SpawnEnemyEffect: Enemy missing required components");
								if ((Object)(object)val3 != (Object)null)
								{
									PhotonNetwork.Destroy(val3);
								}
								RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
							}
							else
							{
								if ((Object)(object)EnemyDirector.instance != (Object)null)
								{
									EnemyDirector.instance.enemiesSpawned.Add(component);
								}
								component.SpawnedTimerReset();
								component3.RPC("UpdateStateRPC", (RpcTarget)0, new object[1] { (object)(State)2 });
								RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_SUCCESS);
							}
						}
					}
					catch (Exception ex2)
					{
						CrowdControlMod.mls.LogError((object)("SpawnEnemyEffect action error: " + ex2.Message + "\n" + ex2.StackTrace));
						RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
					}
				});
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogError((object)("SpawnEnemyEffect error: " + ex.Message + "\n" + ex.StackTrace));
				RPCCommands.MessageHandler.SendResponse(message?.id ?? 0, message?.senderID ?? 0, CrowdResponse.Status.STATUS_FAILURE);
			}
		}
	}
	public class PlayerKillEffect : BaseEffect
	{
		public PlayerKillEffect(ControlClient client, CrowdRequest request)
			: base(client, request)
		{
		}

		public override CrowdResponse Execute()
		{
			request.code.ToLowerInvariant().Contains("random_");
			bool flag = false;
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : (-1));
			if (num == -1)
			{
				return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE);
			}
			if (TimedThread.isRunning(TimedType.KILL))
			{
				return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Cannot Kill Player when they are already dead.");
			}
			if (TimedThread.isRunning(TimedType.INVINCIBLE))
			{
				return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Cannot Kill Player while they are invincible.");
			}
			if (TimedThread.isRunning(TimedType.PRAISE))
			{
				return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
			}
			try
			{
				PlayerHealth result = HelperUtils.FindPlayerHealthByAvatarNumber(num).Result;
				if ((Object)(object)result == (Object)null)
				{
					return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE);
				}
				if (!((Behaviour)result).isActiveAndEnabled)
				{
					return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE);
				}
				if ((Object)(object)((Component)result).GetComponent<PhotonView>() == (Object)null)
				{
					return new CrowdResponse(request.GetReqID(), CrowdResponse.Status.STATUS_FAILURE);
				}
				if ((Object)(object)ChatManager.instance != (Object)null)
				{
					ChatManager.instance.PossessSelfDestruction();
					flag = true;
				}
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogError((object)("Error executing KillPlayer: " + ex.Message));
				flag = false;
			}
			new Thread(new TimedThread(request.GetReqID(), TimedType.KILL, 4000).Run).Start();
			return new TimedResponse(request.GetReqID(), 4000, (!flag) ? CrowdResponse.Status.STATUS_FAILURE : CrowdResponse.Status.STATUS_SUCCESS);
		}
	}
	public class UpgradePlayerEffect : BaseEffect
	{
		public UpgradePlayerEffect(ControlClient client, CrowdRequest request)
			: base(client, request)
		{
		}

		public static async Task Trigger(RPCCommands.MessageHandler.NetworkMessage message)
		{
			_ = 1;
			try
			{
				string upgradeType = Convert.ToString(message.payload["upgrade"]);
				PlayerAvatar val = await HelperUtils.FindPlayerAvatarByNumber(message.targetActor);
				if ((Object)(object)val == (Object)null)
				{
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
					return;
				}
				FieldInfo field = typeof(PlayerAvatar).GetField("steamID", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field == null || field.GetValue(val) == null)
				{
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
					return;
				}
				string steamID = field.GetValue(val).ToString();
				TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					try
					{
						PunManager punManager = Singleton<PunManager>.Instance;
						if (new Dictionary<string, Action>
						{
							{
								"energy",
								delegate
								{
									punManager.UpgradePlayerEnergy(steamID);
								}
							},
							{
								"health",
								delegate
								{
									punManager.UpgradePlayerHealth(steamID);
								}
							},
							{
								"map",
								delegate
								{
									punManager.UpgradeMapPlayerCount(steamID);
								}
							},
							{
								"jump",
								delegate
								{
									punManager.UpgradePlayerExtraJump(steamID);
								}
							},
							{
								"grabrange",
								delegate
								{
									punManager.UpgradePlayerGrabRange(steamID);
								}
							},
							{
								"grabstrength",
								delegate
								{
									punManager.UpgradePlayerGrabStrength(steamID);
								}
							},
							{
								"sprint",
								delegate
								{
									punManager.UpgradePlayerSprintSpeed(steamID);
								}
							},
							{
								"throw",
								delegate
								{
									punManager.UpgradePlayerThrowStrength(steamID);
								}
							},
							{
								"tumble",
								delegate
								{
									punManager.UpgradePlayerTumbleLaunch(steamID);
								}
							}
						}.TryGetValue(upgradeType.ToLower(), out var value))
						{
							value();
							tcs.TrySetResult(result: true);
						}
						else
						{
							CrowdControlMod.mls.LogError((object)("Unknown upgrade type: " + upgradeType));
							tcs.TrySetResult(result: false);
						}
					}
					catch (Exception ex2)
					{
						CrowdControlMod.mls.LogError((object)("Error applying upgrade: " + ex2.Message));
						tcs.TrySetResult(result: false);
					}
				});
				bool flag = await tcs.Task;
				RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, (!flag) ? CrowdResponse.Status.STATUS_FAILURE : CrowdResponse.Status.STATUS_SUCCESS);
			}
			catch (Exception ex)
			{
				CrowdControlMod.mls.LogError((object)("Player upgrade error: " + ex.Message));
				RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE);
			}
		}

		public override CrowdResponse Execute()
		{
			request.code.ToLowerInvariant().Contains("random_");
			int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
			int targetActor = actorNumber;
			string text = ((request.code.Split(new char[1] { '_' }).Length > 1) ? request.code.Split(new char[1] { '_' })[1] : string.Empty);
			if (string.IsNullOrEmpty(text))
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Invalid upgrade type");
			}
			if (!new Dictionary<string, string>
			{
				{ "energy", "Energy" },
				{ "health", "Health" },
				{ "map", "Map Power" },
				{ "jump", "Jumps" },
				{ "grabrange", "Pick-up Range" },
				{ "grabstrength", "Strength" },
				{ "sprint", "Sprint Speed" },
				{ "throw", "Throw Power" },
				{ "tumble", "Tumble Distance" }
			}.TryGetValue(text, out var upgrade))
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Invalid upgrade type");
			}
			try
			{
				TaskCompletionSource<CrowdResponse.Status> tcs = new TaskCompletionSource<CrowdResponse.Status>();
				RPCCommands.MessageHandler.AddResponder(request.id, delegate(CrowdResponse.Status s)
				{
					tcs.SetResult(s);
				});
				RPCCommands.MessageHandler.SendMessageToHost("upgrade_player", request.id, actorNumber, targetActor, new Dictionary<string, object> { { "upgrade", text } });
				if (tcs.Task.Wait(CrowdDelegates.SERVER_TIMEOUT))
				{
					CrowdResponse.Status result = tcs.Task.Result;
					RPCCommands.MessageHandler.RemoveResponder(request.id);
					if (result == CrowdResponse.Status.STATUS_SUCCESS)
					{
						CrowdControlMod.ActionQueue.Enqueue(delegate
						{
							//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)
							MissionUI instance = Singleton<MissionUI>.Instance;
							if (instance != null)
							{
								instance.MissionText("CC Upgraded " + upgrade, Color.green, Color.green, 1f);
							}
						});
					}
					return CreateResponse(result);
				}
				RPCCommands.MessageHandler.RemoveResponder(request.id);
				return CreateResponse(CrowdResponse.Status.STATUS_RETRY);
			}
			catch (Exception)
			{
				return CreateResponse(CrowdResponse.Status.STATUS_FAILURE, "Unable to update haul goal.");
			}
		}
	}
	public abstract class BaseEffect
	{
		protected readonly ControlClient client;

		protected readonly CrowdRequest request;

		protected BaseEffect(ControlClient client, CrowdRequest request)
		{
			this.client = client;
			this.request = request;
		}

		public abstract CrowdResponse Execute();

		protected CrowdResponse CreateResponse(CrowdResponse.Status status, string message = "")
		{
			return new CrowdResponse(request.GetReqID(), status, message);
		}
	}
	public class DamageRandomValuableEffect : BaseEffect
	{
		public DamageRandomValuableEffect(ControlClient client, CrowdRequest request)
			: base(client, request)
		{
		}

		public static async Task Trigger(RPCCommands.MessageHandler.NetworkMessage message)
		{
			_ = 1;
			try
			{
				int targetActor = message.targetActor;
				TaskCompletionSource<bool> tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
				string responseMessage = "";
				PlayerHealth playerHealth = await HelperUtils.FindPlayerHealthByAvatarNumber(targetActor);
				if ((Object)(object)playerHealth == (Object)null)
				{
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE, "Unable to find valuable to damage.");
					return;
				}
				PhotonView component = ((Component)playerHealth).GetComponent<PhotonView>();
				if ((Object)(object)component == (Object)null || component.Owner.ActorNumber != targetActor)
				{
					RPCCommands.MessageHandler.SendResponse(message.id, message.senderID, CrowdResponse.Status.STATUS_FAILURE, "Unable to find valuable to damage.");
					return;
				}
				CrowdControlMod.ActionQueue.Enqueue(delegate
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
					try
					{
						Collider[] array = Physics.OverlapSphere(((Component)playerHealth).transform.position, 5f);
						HashSet<GameObject> hashSet = new HashSet<GameObject>();
						Collider[] array2 = array;
						foreach (Collider val in array2)
						{
							if (((Component)val).CompareTag("Phys Grab Object"))
							{
								Transform root = ((Component)val).transform.root;
								if (((Object)root).name.Contains("Valuable"))
								{
									hashSet.Add(((Component)root).gameObject);
								}
							}
						}
						if (hashSet.Count > 0)
						{
							List<GameObject> list = hashSet.ToList();
							int index = Random.Range(0, list.Count);
							GameObject val2 = list[index];
							PhysGrabObjectImpactDetector component2 = val2.GetComponent<PhysGrabObjectImpactDetector>();
							if ((Object)(object)component2 != (Object)null)
							{
								component2.BreakHeavy(val2.tra