using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.Threading;
using BepInEx;
using BepInEx.Logging;
using DefaultNamespace;
using ExitGames.Client.Photon;
using HarmonyLib;
using MyBox;
using Newtonsoft.Json;
using Photon.Pun;
using Photon.Realtime;
using Unity.Mathematics;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("LethalCompanyTestMod")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalCompanyTestMod")]
[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 BepinControl;

public enum TimedType
{
	PLAYER_ULTRA_SLOW,
	PLAYER_SLOW,
	PLAYER_FAST,
	PLAYER_ULTRA_FAST,
	PLAYER_FREEZE,
	JUMP_LOW,
	JUMP_HIGH,
	JUMP_ULTRA,
	WIDE_CAMERA,
	NARROW_CAMERA,
	FLIP_CAMERA,
	INF_STAM,
	NO_STAM,
	INVUL,
	OHKO
}
public class Timed
{
	public TimedType type;

	private float oldjump;

	private float oldmove;

	public static List<(TimedType, string)> msgs = new List<(TimedType, string)>();

	public static int msgcool = 0;

	private static int frames = 0;

	public static void msgtick()
	{
		if (msgcool > 0)
		{
			msgcool--;
		}
		else if (msgs.Count > 0)
		{
			(TimedType, string) tuple = msgs[0];
			msgs.RemoveAt(0);
			Singleton<HelmetText>.Instance.SetHelmetText(tuple.Item2 ?? "", 1.9f);
			msgcool = 180;
		}
	}

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

	public void addEffect()
	{
		switch (type)
		{
		case TimedType.INF_STAM:
			msgs.Add((type, "INFINITE STAMINA"));
			break;
		case TimedType.NO_STAM:
			msgs.Add((type, "NO STAMINA"));
			break;
		case TimedType.INVUL:
			msgs.Add((type, "INVULNERABLE"));
			break;
		case TimedType.OHKO:
			msgs.Add((type, "ONE HIT KO"));
			break;
		case TimedType.PLAYER_ULTRA_SLOW:
		case TimedType.PLAYER_SLOW:
		case TimedType.PLAYER_FAST:
		case TimedType.PLAYER_ULTRA_FAST:
		case TimedType.PLAYER_FREEZE:
			TestMod.ActionQueue.Enqueue(delegate
			{
				oldmove = Player.localPlayer.refs.controller.movementForce;
			});
			break;
		case TimedType.JUMP_LOW:
			TestMod.ActionQueue.Enqueue(delegate
			{
				msgs.Add((type, "LOW JUMP"));
				oldjump = Player.localPlayer.refs.controller.jumpImpulse;
				Player.localPlayer.refs.controller.jumpImpulse = oldjump / 3f;
			});
			break;
		case TimedType.JUMP_HIGH:
			TestMod.ActionQueue.Enqueue(delegate
			{
				msgs.Add((type, "HIGH JUMP"));
				oldjump = Player.localPlayer.refs.controller.jumpImpulse;
				Player.localPlayer.refs.controller.jumpImpulse = oldjump * 4f;
			});
			break;
		case TimedType.JUMP_ULTRA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				msgs.Add((type, "HIGH JUMP"));
				oldjump = Player.localPlayer.refs.controller.jumpImpulse;
				Player.localPlayer.refs.controller.jumpImpulse = oldjump * 8f;
			});
			break;
		case TimedType.FLIP_CAMERA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				((Component)(Camera)CrowdDelegates.getProperty(MainCamera.instance, "cam")).transform.Rotate(0f, 0f, 180f);
			});
			break;
		case TimedType.WIDE_CAMERA:
		case TimedType.NARROW_CAMERA:
			break;
		}
	}

	public void removeEffect()
	{
		switch (type)
		{
		case TimedType.OHKO:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.CallHeal(PlayerData.maxHealth - 0.01f);
			});
			break;
		case TimedType.FLIP_CAMERA:
			TestMod.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)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				Camera val = (Camera)CrowdDelegates.getProperty(MainCamera.instance, "cam");
				Vector3 position = ((Component)val).transform.position;
				Quaternion val2 = Quaternion.Euler(0f, 0f, 0f);
				((Component)val).transform.SetPositionAndRotation(position, val2);
			});
			break;
		case TimedType.WIDE_CAMERA:
		case TimedType.NARROW_CAMERA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				CrowdDelegates.setProperty(MainCamera.instance, "baseFOV", 70f);
			});
			break;
		case TimedType.PLAYER_ULTRA_SLOW:
		case TimedType.PLAYER_SLOW:
		case TimedType.PLAYER_FAST:
		case TimedType.PLAYER_ULTRA_FAST:
		case TimedType.PLAYER_FREEZE:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = oldmove;
			});
			break;
		case TimedType.JUMP_LOW:
		case TimedType.JUMP_HIGH:
		case TimedType.JUMP_ULTRA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.jumpImpulse = oldjump;
			});
			break;
		case TimedType.INF_STAM:
		case TimedType.NO_STAM:
		case TimedType.INVUL:
			break;
		}
	}

	public void tick()
	{
		frames++;
		switch (type)
		{
		case TimedType.INVUL:
			TestMod.ActionQueue.Enqueue(delegate
			{
				if (Player.localPlayer.data.health < PlayerData.maxHealth)
				{
					CrowdDelegates.callFunc(Player.localPlayer, "Heal", new object[1] { PlayerData.maxHealth });
				}
			});
			break;
		case TimedType.OHKO:
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (Player.localPlayer.data.health > 1f)
				{
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(0f, 0f, 0f);
					CrowdDelegates.callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3]
					{
						Player.localPlayer.data.health - 1f,
						val,
						0
					});
				}
			});
			break;
		case TimedType.INF_STAM:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.data.currentStamina = 10f;
			});
			break;
		case TimedType.NO_STAM:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.data.currentStamina = 0f;
			});
			break;
		case TimedType.WIDE_CAMERA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				CrowdDelegates.setProperty(MainCamera.instance, "baseFOV", 100f);
			});
			break;
		case TimedType.NARROW_CAMERA:
			TestMod.ActionQueue.Enqueue(delegate
			{
				CrowdDelegates.setProperty(MainCamera.instance, "baseFOV", 40f);
			});
			break;
		case TimedType.PLAYER_ULTRA_SLOW:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = 2.5f;
			});
			break;
		case TimedType.PLAYER_FREEZE:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = 0f;
			});
			break;
		case TimedType.PLAYER_SLOW:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = 5f;
			});
			break;
		case TimedType.PLAYER_FAST:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = 20f;
			});
			break;
		case TimedType.PLAYER_ULTRA_FAST:
			TestMod.ActionQueue.Enqueue(delegate
			{
				Player.localPlayer.refs.controller.movementForce = 40f;
			});
			break;
		case TimedType.JUMP_LOW:
		case TimedType.JUMP_HIGH:
		case TimedType.JUMP_ULTRA:
		case TimedType.FLIP_CAMERA:
			break;
		}
	}
}
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)
		{
			TestMod.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)
		{
			TestMod.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)
		{
			TestMod.mls.LogInfo((object)ex.ToString());
		}
	}

	public TimedThread(int id, TimedType type, int duration)
	{
		effect = new Timed(type);
		this.duration = duration;
		remain = duration;
		this.id = id;
		paused = false;
		try
		{
			lock (threads)
			{
				threads.Add(this);
			}
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)ex.ToString());
		}
	}

	public void Run()
	{
		Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
		effect.addEffect();
		try
		{
			for (int num = Volatile.Read(ref duration); num > 0; num = Volatile.Read(ref duration))
			{
				Interlocked.Add(ref duration, -num);
				Thread.Sleep(num);
			}
			effect.removeEffect();
			lock (threads)
			{
				threads.Remove(this);
			}
			new TimedResponse(id, 0, CrowdResponse.Status.STATUS_STOP).Send(ControlClient.Socket);
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)ex.ToString());
		}
	}
}
[BepInPlugin("WarpWorld.CrowdControl", "Crowd Control", "1.0.1.0")]
public class TestMod : BaseUnityPlugin, IOnEventCallback
{
	private const string modGUID = "WarpWorld.CrowdControl";

	private const string modName = "Crowd Control";

	private const string modVersion = "1.0.1.0";

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

	public static ManualLogSource mls;

	internal static TestMod Instance = null;

	private ControlClient client;

	public static RoundSpawner spawner = null;

	public static List<IBudgetCost> spawns = new List<IBudgetCost>();

	public static Random rnd = new Random();

	public static List<string> comments = new List<string>();

	private const int MSG_CC = 33;

	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(TestMod));
		mls.LogInfo((object)"Initializing Crowd Control");
		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;
	}

	private void Update()
	{
		if (ActionQueue.Count > 0)
		{
			ActionQueue.Dequeue()();
		}
		lock (TimedThread.threads)
		{
			Timed.msgtick();
			foreach (TimedThread thread in TimedThread.threads)
			{
				if (!thread.paused)
				{
					thread.effect.tick();
				}
			}
		}
	}

	public static void SendPlayerStats(Player player)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[4]
		{
			"stats",
			Player.localPlayer.refs.view.ViewID,
			Player.localPlayer.data.remainingOxygen,
			Player.localPlayer.data.health
		}, val, SendOptions.SendReliable);
	}

	public static void SendRoundStats()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[3]
		{
			"round",
			SurfaceNetworkHandler.RoomStats.CurrentQuota,
			SurfaceNetworkHandler.RoomStats.Money
		}, val, SendOptions.SendReliable);
	}

	public static void SendGiveItem(Player player, byte item)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_003f: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[3]
		{
			"item",
			player.refs.view.ViewID,
			item
		}, val, SendOptions.SendReliable);
	}

	public static void SendSpawn(Player player, string code)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[3]
		{
			"spawn",
			player.refs.view.ViewID,
			code
		}, val, SendOptions.SendReliable);
	}

	public static void SendKill(Player player)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[2]
		{
			"kill",
			player.refs.view.ViewID
		}, val, SendOptions.SendReliable);
	}

	public static void SendTele(Player from, Player to)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_004e: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[3]
		{
			"tele",
			from.refs.view.ViewID,
			to.refs.view.ViewID
		}, val, SendOptions.SendReliable);
	}

	public static void SendTeleBell(Player from)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Expected O, but got Unknown
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		RaiseEventOptions val = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)1
		};
		PhotonNetwork.RaiseEvent((byte)33, (object)new object[2]
		{
			"telebell",
			from.refs.view.ViewID
		}, val, SendOptions.SendReliable);
	}

	public void OnEvent(EventData photonEvent)
	{
		//IL_038e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0395: Expected O, but got Unknown
		//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_03ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0164: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: Unknown result type (might be due to invalid IL or missing references)
		//IL_0182: Unknown result type (might be due to invalid IL or missing references)
		//IL_0188: Unknown result type (might be due to invalid IL or missing references)
		//IL_018d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0198: Unknown result type (might be due to invalid IL or missing references)
		//IL_019d: Unknown result type (might be due to invalid IL or missing references)
		//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0202: Unknown result type (might be due to invalid IL or missing references)
		//IL_020c: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0213: Unknown result type (might be due to invalid IL or missing references)
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01df: Unknown result type (might be due to invalid IL or missing references)
		//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d6: Expected O, but got Unknown
		//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
		//IL_04f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0502: Unknown result type (might be due to invalid IL or missing references)
		//IL_0507: Unknown result type (might be due to invalid IL or missing references)
		//IL_0511: Unknown result type (might be due to invalid IL or missing references)
		//IL_0516: Unknown result type (might be due to invalid IL or missing references)
		//IL_0520: Unknown result type (might be due to invalid IL or missing references)
		//IL_0546: Unknown result type (might be due to invalid IL or missing references)
		//IL_0558: Unknown result type (might be due to invalid IL or missing references)
		//IL_030d: Unknown result type (might be due to invalid IL or missing references)
		//IL_031c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0321: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (photonEvent.Code != 33)
			{
				return;
			}
			object[] array = (object[])photonEvent.CustomData;
			string text = (string)array[0];
			if (text == null)
			{
				return;
			}
			switch (text.Length)
			{
			case 5:
				switch (text[1])
				{
				case 'p':
					if (text == "spawn" && Player.localPlayer.refs.view.ViewID == (int)array[1])
					{
						float num = 15f;
						RaycastHit val9 = HelperFunctions.LineCheck(((Component)MainCamera.instance).transform.position, ((Component)MainCamera.instance).transform.position + ((Component)MainCamera.instance).transform.forward * num, (LayerType)1, 0f);
						Vector3 val10 = ((Component)MainCamera.instance).transform.position + ((Component)MainCamera.instance).transform.forward * num;
						if ((Object)(object)((RaycastHit)(ref val9)).collider != (Object)null)
						{
							val10 = ((RaycastHit)(ref val9)).point;
						}
						val10 = HelperFunctions.GetGroundPos(val10 + Vector3.up * 1f, (LayerType)1, 0f);
						PhotonNetwork.Instantiate((string)array[2], val10, quaternion.op_Implicit(quaternion.identity), (byte)0, (object[])null);
					}
					break;
				case 't':
				{
					if (!(text == "stats"))
					{
						break;
					}
					for (int k = 0; k < PlayerHandler.instance.players.Count; k++)
					{
						Player val2 = PlayerHandler.instance.players[k];
						if (val2.refs.view.ViewID == (int)array[1])
						{
							val2.data.remainingOxygen = (float)array[2];
							val2.data.health = (float)array[3];
							break;
						}
					}
					break;
				}
				case 'o':
					if (text == "round")
					{
						CrowdDelegates.setProperty(SurfaceNetworkHandler.RoomStats, "currentQuoutaInternal", (int)array[1]);
						SurfaceNetworkHandler.RoomStats.AddMoney((int)array[2] - SurfaceNetworkHandler.RoomStats.Money);
					}
					break;
				}
				break;
			case 4:
				switch (text[0])
				{
				case 't':
				{
					if (!(text == "tele") || Player.localPlayer.refs.view.ViewID != (int)array[1])
					{
						break;
					}
					for (int j = 0; j < PlayerHandler.instance.players.Count; j++)
					{
						Player val2 = PlayerHandler.instance.players[j];
						if (val2.refs.view.ViewID == (int)array[2])
						{
							CrowdDelegates.callFunc(Player.localPlayer.refs.ragdoll, "MoveAllRigsInDirection", val2.data.groundPos - Player.localPlayer.data.groundPos);
							break;
						}
					}
					break;
				}
				case 'k':
					if (text == "kill" && Player.localPlayer.refs.view.ViewID == (int)array[1])
					{
						CrowdDelegates.callFunc(Player.localPlayer, "CallDie", null);
					}
					break;
				case 'i':
				{
					if (!(text == "item") || !PhotonNetwork.IsMasterClient)
					{
						break;
					}
					byte b = (byte)array[2];
					Player val2 = null;
					for (int i = 0; i < PlayerHandler.instance.players.Count; i++)
					{
						if (PlayerHandler.instance.players[i].refs.view.ViewID == (int)array[1])
						{
							val2 = PlayerHandler.instance.players[i];
							break;
						}
					}
					if (!Object.op_Implicit((Object)(object)val2))
					{
						break;
					}
					ItemInstanceData val3 = new ItemInstanceData(Guid.NewGuid());
					Vector3 position = ((Component)val2).transform.position;
					PlayerInventory val4 = default(PlayerInventory);
					if (!val2.TryGetInventory(ref val4))
					{
						break;
					}
					Pickup val5 = PickupHandler.CreatePickup(b, val3, position, Random.rotation, (Vector3.up + Random.onUnitSphere) * 2f, Random.onUnitSphere * 5f);
					Item val6 = default(Item);
					if (ItemDatabase.TryGetItemFromID(b, ref val6))
					{
						ItemInstanceData val7 = ((ItemInstanceData)CrowdDelegates.getProperty(val5, "instanceData")).Copy();
						InventorySlot val8 = default(InventorySlot);
						if (val4.TryAddItem(new ItemDescriptor(val6, val7), ref val8))
						{
							val2.refs.view.RPC("RPC_SelectSlot", val2.refs.view.Owner, new object[1] { val8.SlotID });
							val5.m_photonView.RPC("RPC_Remove", (RpcTarget)2, Array.Empty<object>());
							val4.SyncInventoryToOthers();
						}
					}
					break;
				}
				}
				break;
			case 8:
				if (text == "telebell" && Player.localPlayer.refs.view.ViewID == (int)array[1])
				{
					Transform val = (Transform)CrowdDelegates.callAndReturnFunc(SpawnHandler.Instance, "GetSpawnPoint", (object)(Spawns)3);
					CrowdDelegates.callFunc(Player.localPlayer.refs.ragdoll, "MoveAllRigsInDirection", val.position - Player.localPlayer.data.groundPos);
				}
				break;
			case 6:
			case 7:
				break;
			}
		}
		catch (Exception)
		{
		}
	}

	private void OnEnable()
	{
		PhotonNetwork.AddCallbackTarget((object)this);
	}

	private void OnDisable()
	{
		PhotonNetwork.RemoveCallbackTarget((object)this);
	}

	[HarmonyPatch(typeof(Player), "FixedUpdate")]
	[HarmonyPrefix]
	private static void RunEffects()
	{
	}

	[HarmonyPatch(typeof(RoundSpawner), "SpawnRound")]
	[HarmonyPrefix]
	private static void Spawning(RoundSpawner __instance)
	{
		spawner = __instance;
	}

	[HarmonyPatch(typeof(ContentBuffer), "GenerateComments")]
	[HarmonyPostfix]
	private static void Comments(List<Comment> __result)
	{
		string[] array = new string[9] { "<playername> are you using Crowd Control?", "Wait? Is this Crowd Control enabled?", "Crowd Control?", "How do I use Crowd Control?", "<playername> is using Crowd Control!!!", "I didn't know this had Crowd Control!", "What is Crowd Control?", "Why does everyone keep saying Crowd Control?", "The Crowd Control team is awesome!" };
		foreach (Comment item in __result)
		{
			if (comments.Count() > 1)
			{
				if (rnd.Next(4) == 1)
				{
					int index = rnd.Next(comments.Count());
					item.Text = comments[index];
					Player val = PlayerHandler.instance.players[rnd.Next(PlayerHandler.instance.players.Count())];
					item.Text = item.Text.Replace("<playername>", ((Object)val).name);
					comments.RemoveAt(index);
				}
			}
			else if (rnd.Next(8) == 1)
			{
				item.Text = array[rnd.Next(array.Count())];
				Player val2 = PlayerHandler.instance.players[rnd.Next(PlayerHandler.instance.players.Count())];
				item.Text = item.Text.Replace("<playername>", ((Object)val2).name);
			}
		}
		comments.Clear();
	}
}
public class ControlClient
{
	public static readonly string CV_HOST = "127.0.0.1";

	public static readonly int CV_PORT = 51337;

	private bool paused;

	public bool inGame = true;

	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>
		{
			{
				"money100",
				CrowdDelegates.Money100
			},
			{
				"sound",
				CrowdDelegates.MakeSound
			},
			{
				"kill",
				CrowdDelegates.Kill
			},
			{
				"damage",
				CrowdDelegates.Damage10
			},
			{
				"damageb",
				CrowdDelegates.Damage30
			},
			{
				"heal",
				CrowdDelegates.Heal10
			},
			{
				"healb",
				CrowdDelegates.Heal30
			},
			{
				"healf",
				CrowdDelegates.HealFull
			},
			{
				"launch",
				CrowdDelegates.Launch
			},
			{
				"megalaunch",
				CrowdDelegates.MegaLaunch
			},
			{
				"forward",
				CrowdDelegates.ShoveForward
			},
			{
				"backward",
				CrowdDelegates.YankBackwards
			},
			{
				"ragdoll",
				CrowdDelegates.Ragdoll
			},
			{
				"giveo210",
				CrowdDelegates.GiveOxygen10
			},
			{
				"giveo230",
				CrowdDelegates.GiveOxygen30
			},
			{
				"giveo2100",
				CrowdDelegates.GiveOxygen100
			},
			{
				"takeo210",
				CrowdDelegates.TakeOxygen10
			},
			{
				"takeo230",
				CrowdDelegates.TakeOxygen30
			},
			{
				"takeo2100",
				CrowdDelegates.TakeOxygen100
			},
			{
				"fillstam",
				CrowdDelegates.FillStamina
			},
			{
				"emptystam",
				CrowdDelegates.EmptyStamina
			},
			{
				"infstam",
				CrowdDelegates.InfStam
			},
			{
				"nostam",
				CrowdDelegates.NoStam
			},
			{
				"invul",
				CrowdDelegates.Invul
			},
			{
				"ohko",
				CrowdDelegates.OHKO
			},
			{
				"ultraslow",
				CrowdDelegates.UltraSlow
			},
			{
				"slow",
				CrowdDelegates.Slow
			},
			{
				"fast",
				CrowdDelegates.Fast
			},
			{
				"ultrafast",
				CrowdDelegates.UltraFast
			},
			{
				"freeze",
				CrowdDelegates.Freeze
			},
			{
				"lowjump",
				CrowdDelegates.LowJump
			},
			{
				"highjump",
				CrowdDelegates.HighJump
			},
			{
				"ultrajump",
				CrowdDelegates.UltraJump
			},
			{
				"jump",
				CrowdDelegates.Jump
			},
			{
				"giveitem_mic",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_camera",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_clapper",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_defib",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_flare",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_gooball",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_hugger",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_light",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_party",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_shock",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_sound",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_chorby",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_brain",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_radio",
				CrowdDelegates.GiveItem
			},
			{
				"giveitem_skull",
				CrowdDelegates.GiveItem
			},
			{
				"cgiveitem_mic",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_camera",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_clapper",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_defib",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_flare",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_gooball",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_hugger",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_light",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_party",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_shock",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_sound",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_chorby",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_brain",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_radio",
				CrowdDelegates.GiveCrewItem
			},
			{
				"cgiveitem_skull",
				CrowdDelegates.GiveCrewItem
			},
			{
				"dropitem",
				CrowdDelegates.DropItem
			},
			{
				"takeitem",
				CrowdDelegates.TakeItem
			},
			{
				"spawn_Jello",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Zombe",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Spider",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Snatcho",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Bombs",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_BarnacleBall",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Dog",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Ear",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_BigSlap",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_EyeGuy",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Flicker",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Harpoon",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Mouthe",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Whisk",
				CrowdDelegates.SpawnMonster
			},
			{
				"spawn_Weeping",
				CrowdDelegates.SpawnMonster
			},
			{
				"cspawn_Jello",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Zombe",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Spider",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Snatcho",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Bombs",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_BarnacleBall",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Dog",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Ear",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_BigSlap",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_EyeGuy",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Flicker",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Harpoon",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Mouthe",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Whisk",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"cspawn_Weeping",
				CrowdDelegates.SpawnMonsterCrew
			},
			{
				"shake",
				CrowdDelegates.ShakeScreen
			},
			{
				"shakebig",
				CrowdDelegates.ShakeScreenBig
			},
			{
				"widecam",
				CrowdDelegates.WideCamera
			},
			{
				"narrowcam",
				CrowdDelegates.NarrowCamera
			},
			{
				"flipcam",
				CrowdDelegates.FlipCamera
			},
			{
				"money_10",
				CrowdDelegates.GiveMoney
			},
			{
				"money_100",
				CrowdDelegates.GiveMoney
			},
			{
				"money_1000",
				CrowdDelegates.GiveMoney
			},
			{
				"money_-10",
				CrowdDelegates.GiveMoney
			},
			{
				"money_-100",
				CrowdDelegates.GiveMoney
			},
			{
				"money_-1000",
				CrowdDelegates.GiveMoney
			},
			{
				"views_10",
				CrowdDelegates.GiveViews
			},
			{
				"views_30",
				CrowdDelegates.GiveViews
			},
			{
				"views_100",
				CrowdDelegates.GiveViews
			},
			{
				"views_-10",
				CrowdDelegates.GiveViews
			},
			{
				"views_-30",
				CrowdDelegates.GiveViews
			},
			{
				"views_-100",
				CrowdDelegates.GiveViews
			},
			{
				"face_0",
				CrowdDelegates.SetColor
			},
			{
				"face_1",
				CrowdDelegates.SetColor
			},
			{
				"face_2",
				CrowdDelegates.SetColor
			},
			{
				"face_3",
				CrowdDelegates.SetColor
			},
			{
				"face_4",
				CrowdDelegates.SetColor
			},
			{
				"face_5",
				CrowdDelegates.SetColor
			},
			{
				"face_6",
				CrowdDelegates.SetColor
			},
			{
				"face_7",
				CrowdDelegates.SetColor
			},
			{
				"opendoor",
				CrowdDelegates.OpenDoor
			},
			{
				"closedoor",
				CrowdDelegates.CloseDoor
			},
			{
				"teleto",
				CrowdDelegates.TeleToCrew
			},
			{
				"telecrew",
				CrowdDelegates.TeleCrew
			},
			{
				"teletobell",
				CrowdDelegates.TeleToBell
			},
			{
				"telecrewbell",
				CrowdDelegates.TeleCrewBell
			},
			{
				"killcrew",
				CrowdDelegates.KillCrew
			}
		};
	}

	public bool isReady()
	{
		try
		{
			if ((Object)(object)Player.localPlayer == (Object)null)
			{
				return false;
			}
		}
		catch (Exception ex)
		{
			TestMod.mls.LogError((object)ex.ToString());
			return false;
		}
		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()
	{
		TestMod.mls.LogInfo((object)"Connected to Crowd Control");
		new Timer(timeUpdate, null, 0, 200);
		try
		{
			while (Running)
			{
				CrowdRequest crowdRequest = CrowdRequest.Recieve(this, Socket);
				if (crowdRequest != null && !crowdRequest.IsKeepAlive())
				{
					lock (Requests)
					{
						Requests.Enqueue(crowdRequest);
					}
				}
			}
		}
		catch (Exception)
		{
			TestMod.mls.LogInfo((object)"Disconnected from Crowd Control");
			Socket.Close();
		}
	}

	public void timeUpdate(object state)
	{
		inGame = true;
		if (!isReady())
		{
			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)
		{
			TestMod.mls.LogInfo((object)"Attempting to connect to Crowd Control");
			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
				{
					TestMod.mls.LogInfo((object)"Failed to connect to Crowd Control");
				}
				Socket.Close();
			}
			catch (Exception ex)
			{
				TestMod.mls.LogInfo((object)ex.GetType().Name);
				TestMod.mls.LogInfo((object)"Failed to connect to Crowd Control");
			}
			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
				{
					CrowdResponse crowdResponse = (isReady() ? Delegate[reqCode](this, crowdRequest) : new CrowdResponse(crowdRequest.GetReqID(), CrowdResponse.Status.STATUS_RETRY));
					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)
			{
				TestMod.mls.LogInfo((object)"Disconnected from Crowd Control");
				Socket.Close();
			}
		}
	}

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

	private static readonly Dictionary<string, byte> items = new Dictionary<string, byte>
	{
		{ "mic", 0 },
		{ "camera", 1 },
		{ "clapper", 3 },
		{ "defib", 4 },
		{ "flare", 7 },
		{ "gooball", 8 },
		{ "hugger", 10 },
		{ "light", 12 },
		{ "party", 17 },
		{ "shock", 20 },
		{ "sound", 21 },
		{ "chorby", 32 },
		{ "brain", 31 },
		{ "radio", 35 },
		{ "skull", 39 }
	};

	public static CrowdResponse Money100(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				((PerlinShake)getProperty(GamefeelHandler.instance, "perlin")).AddShake(15f, 0.2f, 15f);
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveMoney(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		int num = int.Parse(code);
		if (num < 0 && SurfaceNetworkHandler.RoomStats.Money + num < 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				SurfaceNetworkHandler.RoomStats.AddMoney(num);
				if (num > 0)
				{
					Singleton<UserInterface>.Instance.moneyAddedUI.Show("Crowd Control", "$" + num, (MoneyCellType)1);
				}
				else
				{
					Singleton<UserInterface>.Instance.moneyAddedUI.Show("Crowd Control", "$" + num, (MoneyCellType)0);
				}
				TestMod.SendRoundStats();
				if (num > 0)
				{
					TestMod.comments.Add("Yo, free money! Thanks Crowd Control!");
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse SetColor(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		int num = int.Parse(code);
		PlayerCustomizer playerCustomizer = Object.FindObjectOfType<PlayerCustomizer>();
		if ((Object)(object)playerCustomizer == (Object)null)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				playerCustomizer.RPCA_PickColor(num);
				playerCustomizer.RPCA_PlayerLeftTerminal(true);
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveViews(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		int num = int.Parse(code);
		if (num == -100)
		{
			num = -SurfaceNetworkHandler.RoomStats.CurrentQuota;
			if (num == 0)
			{
				return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
			}
		}
		else
		{
			num = SurfaceNetworkHandler.RoomStats.QuotaToReach * num / 100;
		}
		if (num < 0 && SurfaceNetworkHandler.RoomStats.CurrentQuota + num < 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				setProperty(SurfaceNetworkHandler.RoomStats, "currentQuoutaInternal", SurfaceNetworkHandler.RoomStats.CurrentQuota + num);
				callFunc(SurfaceNetworkHandler.RoomStats, "OnStatsUpdated", null);
				if (num > 0)
				{
					Singleton<UserInterface>.Instance.moneyAddedUI.Show("Crowd Control", num + "0 Views", (MoneyCellType)1);
				}
				else
				{
					Singleton<UserInterface>.Instance.moneyAddedUI.Show("Crowd Control", num + "0 Views", (MoneyCellType)0);
				}
				TestMod.SendRoundStats();
				if (num > 0)
				{
					TestMod.comments.Add("I watched this before it was even uploaded! #CrowdControl");
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse ShakeScreen(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				((PerlinShake)getProperty(GamefeelHandler.instance, "perlin")).AddShake(15f, 0.2f, 15f);
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TeleToCrew(ControlClient client, CrowdRequest req)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		Player player = null;
		List<Player> list = new List<Player>();
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer)
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		player = list[index];
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					callFunc(Player.localPlayer.refs.ragdoll, "MoveAllRigsInDirection", player.data.groundPos - Player.localPlayer.data.groundPos);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TeleToBell(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				//IL_0030: 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_0044: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Transform val = (Transform)callAndReturnFunc(SpawnHandler.Instance, "GetSpawnPoint", (object)(Spawns)3);
					callFunc(Player.localPlayer.refs.ragdoll, "MoveAllRigsInDirection", val.position - Player.localPlayer.data.groundPos);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TeleCrew(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		List<Player> list = new List<Player>();
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer)
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		TestMod.SendTele(list[index], Player.localPlayer);
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TeleCrewBell(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		List<Player> list = new List<Player>();
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer)
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		TestMod.SendTeleBell(list[index]);
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse KillCrew(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		Player val = null;
		List<Player> list = new List<Player>();
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer)
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		val = list[index];
		TestMod.SendKill(val);
		TestMod.comments.Add("Was " + val.refs.view.Owner.NickName + " killed by Crowd Control?");
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveCrewItem(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		byte b = 0;
		b = ((DatabaseAsset<ItemDatabase, Item>)(object)SingletonAsset<ItemDatabase>.Instance).Objects.ToList().Find((Item x) => ((Object)x).name.ToLower().Contains(code)).id;
		Player val = null;
		List<Player> list = new List<Player>();
		PlayerInventory val2 = default(PlayerInventory);
		InventorySlot val3 = default(InventorySlot);
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer && item.TryGetInventory(ref val2) && val2.TryGetFeeSlot(ref val3) && (!((Object)(object)item.data.currentItem != (Object)null) || item.data.selectedItemSlot != -1))
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		val = list[index];
		TestMod.SendGiveItem(val, b);
		TestMod.comments.Add("I gave " + val.refs.view.Owner.NickName + " a item!");
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse OpenDoor(ControlClient client, CrowdRequest req)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		DivingBell bell = Object.FindObjectOfType<DivingBell>();
		if ((Object)(object)bell == (Object)null)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if ((bool)getProperty(bell, "m_isMovingDoor") || bell.opened)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				bell.AttemptSetOpen(true);
				TestMod.comments.Add("Someone is controlling the door with Crowd Control!");
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse CloseDoor(ControlClient client, CrowdRequest req)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		DivingBell bell = Object.FindObjectOfType<DivingBell>();
		if ((Object)(object)bell == (Object)null)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if ((bool)getProperty(bell, "m_isMovingDoor") || !bell.opened)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				TestMod.comments.Add("Someone is controlling the door with Crowd Control!");
				bell.AttemptSetOpen(false);
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse ShakeScreenBig(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				((PerlinShake)getProperty(GamefeelHandler.instance, "perlin")).AddShake(25f, 3.5f, 25f);
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse SpawnMonster(ControlClient client, CrowdRequest req)
	{
		//IL_0031: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		if (code == "Whisk")
		{
			code = "Toolkit_Wisk";
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: 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_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					float num = 15f;
					RaycastHit val = HelperFunctions.LineCheck(((Component)MainCamera.instance).transform.position, ((Component)MainCamera.instance).transform.position + ((Component)MainCamera.instance).transform.forward * num, (LayerType)1, 0f);
					Vector3 val2 = ((Component)MainCamera.instance).transform.position + ((Component)MainCamera.instance).transform.forward * num;
					if ((Object)(object)((RaycastHit)(ref val)).collider != (Object)null)
					{
						val2 = ((RaycastHit)(ref val)).point;
					}
					val2 = HelperFunctions.GetGroundPos(val2 + Vector3.up * 1f, (LayerType)1, 0f);
					PhotonNetwork.Instantiate(code, val2, quaternion.op_Implicit(quaternion.identity), (byte)0, (object[])null);
					TestMod.comments.Add("Where did that monster come from? Is that Crowd Control?");
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse SpawnMonsterCrew(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		if (code == "Whisk")
		{
			code = "Toolkit_Wisk";
		}
		Player val = null;
		List<Player> list = new List<Player>();
		foreach (Player item in PlayerHandler.instance.playersAlive)
		{
			if ((Object)(object)item != (Object)(object)Player.localPlayer && !item.data.dead && !item.data.isInDiveBell)
			{
				list.Add(item);
			}
		}
		if (list.Count == 0)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int index = rnd.Next(list.Count);
		val = list[index];
		try
		{
			TestMod.SendSpawn(val, code);
			TestMod.comments.Add("Where did that monster come from? Is that Crowd Control?");
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveItem(ControlClient client, CrowdRequest req)
	{
		//IL_014a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0154: Expected O, but got Unknown
		//IL_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if ((Object)(object)Player.localPlayer.data.currentItem != (Object)null && Player.localPlayer.data.selectedItemSlot == -1)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		string code = req.code;
		code = code.Split(new char[1] { '_' })[1];
		byte b = 0;
		b = ((DatabaseAsset<ItemDatabase, Item>)(object)SingletonAsset<ItemDatabase>.Instance).Objects.ToList().Find((Item x) => ((Object)x).name.ToLower().Contains(code)).id;
		try
		{
			PlayerInventory playerInventory = default(PlayerInventory);
			if (!Player.localPlayer.TryGetInventory(ref playerInventory))
			{
				return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
			}
			InventorySlot val = default(InventorySlot);
			if (!playerInventory.TryGetFeeSlot(ref val))
			{
				return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
			}
			if (!PhotonNetwork.IsMasterClient)
			{
				TestMod.SendGiveItem(Player.localPlayer, b);
				return new CrowdResponse(req.GetReqID(), status, message);
			}
			byte itemid = b;
			ItemInstanceData pickupdata = new ItemInstanceData(Guid.NewGuid());
			Vector3 pos = ((Component)Player.localPlayer).transform.position;
			Item item = default(Item);
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: 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_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Pickup val2 = PickupHandler.CreatePickup(itemid, pickupdata, pos, Random.rotation, (Vector3.up + Random.onUnitSphere) * 2f, Random.onUnitSphere * 5f);
					if (ItemDatabase.TryGetItemFromID(itemid, ref item))
					{
						ItemInstanceData val3 = ((ItemInstanceData)getProperty(val2, "instanceData")).Copy();
						InventorySlot val4 = default(InventorySlot);
						if (playerInventory.TryAddItem(new ItemDescriptor(item, val3), ref val4))
						{
							Player.localPlayer.refs.view.RPC("RPC_SelectSlot", Player.localPlayer.refs.view.Owner, new object[1] { val4.SlotID });
							val2.m_photonView.RPC("RPC_Remove", (RpcTarget)2, Array.Empty<object>());
							playerInventory.SyncInventoryToOthers();
							TestMod.comments.Add("You're welcome for the item " + Player.localPlayer.refs.view.Owner.NickName + "!");
						}
					}
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse DropItem(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if ((Object)(object)Player.localPlayer.data.currentItem == (Object)null)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.selectedItemSlot == -1)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					Player.localPlayer.refs.items.DropItem(Player.localPlayer.data.selectedItemSlot, false);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TakeItem(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is safe in Diving Bell");
		}
		if ((Object)(object)Player.localPlayer.data.currentItem == (Object)null)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.selectedItemSlot == -1)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		PlayerInventory playerInventory = default(PlayerInventory);
		if (!Player.localPlayer.TryGetInventory(ref playerInventory))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					ItemDescriptor val = default(ItemDescriptor);
					playerInventory.TryRemoveItemFromSlot(Player.localPlayer.data.selectedItemSlot, ref val);
					TestMod.comments.Add("Someone took the item away with Crowd Control!");
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse InfStam(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.INF_STAM))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.NO_STAM))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.INF_STAM, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse Invul(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.INVUL))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.OHKO))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.INVUL, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse OHKO(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.INF_STAM))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.OHKO))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.OHKO, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse NoStam(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.INF_STAM))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.NO_STAM))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.NO_STAM, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse FlipCamera(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is safe in Diving Bell.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.FLIP_CAMERA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		TestMod.comments.Add("Oh god, the camera!");
		new Thread(new TimedThread(req.GetReqID(), TimedType.FLIP_CAMERA, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse WideCamera(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is safe in Diving Bell.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.WIDE_CAMERA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.NARROW_CAMERA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.WIDE_CAMERA, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse NarrowCamera(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is safe in Diving Bell.");
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.WIDE_CAMERA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.NARROW_CAMERA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.NARROW_CAMERA, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse UltraSlow(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FREEZE))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.PLAYER_ULTRA_SLOW, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse Slow(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FREEZE))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.PLAYER_SLOW, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse Fast(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FREEZE))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.PLAYER_FAST, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse UltraFast(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FREEZE))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		TestMod.comments.Add("woah! " + Player.localPlayer.refs.view.Owner.NickName + " is so fast! #CrowdControl");
		new Thread(new TimedThread(req.GetReqID(), TimedType.PLAYER_ULTRA_FAST, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse Freeze(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_SLOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_ULTRA_FAST))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.PLAYER_FREEZE))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		TestMod.comments.Add("I froze " + Player.localPlayer.refs.view.Owner.NickName + " with Crowd Control! hahahaha");
		new Thread(new TimedThread(req.GetReqID(), TimedType.PLAYER_FREEZE, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse LowJump(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.JUMP_LOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_HIGH))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_ULTRA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.JUMP_LOW, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse HighJump(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.JUMP_LOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_HIGH))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_ULTRA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.JUMP_HIGH, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse UltraJump(ControlClient client, CrowdRequest req)
	{
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		int num = 30;
		if (req.duration > 0)
		{
			num = req.duration / 1000;
		}
		if (TimedThread.isRunning(TimedType.JUMP_LOW))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_HIGH))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (TimedThread.isRunning(TimedType.JUMP_ULTRA))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		new Thread(new TimedThread(req.GetReqID(), TimedType.JUMP_ULTRA, num * 1000).Run).Start();
		return new TimedResponse(req.GetReqID(), num * 1000);
	}

	public static CrowdResponse TakeOxygen10(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.remainingOxygen <= 50f)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					TakeDamagePost.instance.TakeDamageFeedback();
					UI_Feedback.instance.TakeDamage(false);
					PlayerData data = Player.localPlayer.data;
					data.remainingOxygen -= 50f;
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse Jump(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (!(Player.localPlayer.data.sinceGrounded < 0.5f) || !(Player.localPlayer.data.sinceJump > 0.6f))
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					Player.localPlayer.refs.controller.TryJump();
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TakeOxygen30(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.remainingOxygen <= 150f)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					TakeDamagePost.instance.TakeDamageFeedback();
					UI_Feedback.instance.TakeDamage(false);
					PlayerData data = Player.localPlayer.data;
					data.remainingOxygen -= 150f;
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse TakeOxygen100(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.remainingOxygen <= 50f)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					TakeDamagePost.instance.TakeDamageFeedback();
					UI_Feedback.instance.TakeDamage(false);
					Player.localPlayer.data.remainingOxygen = 0f;
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveOxygen10(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.remainingOxygen >= Player.localPlayer.data.maxOxygen)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					UI_Feedback.instance.HealFeedback();
					PlayerData data = Player.localPlayer.data;
					data.remainingOxygen += 50f;
					if (Player.localPlayer.data.remainingOxygen > Player.localPlayer.data.maxOxygen)
					{
						Player.localPlayer.data.remainingOxygen = Player.localPlayer.data.maxOxygen;
					}
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveOxygen30(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.remainingOxygen >= Player.localPlayer.data.maxOxygen)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					UI_Feedback.instance.HealFeedback();
					PlayerData data = Player.localPlayer.data;
					data.remainingOxygen += 150f;
					if (Player.localPlayer.data.remainingOxygen > Player.localPlayer.data.maxOxygen)
					{
						Player.localPlayer.data.remainingOxygen = Player.localPlayer.data.maxOxygen;
					}
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse GiveOxygen100(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.remainingOxygen >= Player.localPlayer.data.maxOxygen)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					UI_Feedback.instance.HealFeedback();
					Player.localPlayer.data.remainingOxygen = Player.localPlayer.data.maxOxygen;
					TestMod.SendPlayerStats(Player.localPlayer);
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse FillStamina(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.currentStamina >= 10f)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					UI_Feedback.instance.HealFeedback();
					Player.localPlayer.data.currentStamina = 10f;
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse EmptyStamina(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.localPlayer.data.currentStamina <= 0f)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY, message);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				try
				{
					TakeDamagePost.instance.TakeDamageFeedback();
					UI_Feedback.instance.TakeDamage(false);
					Player.localPlayer.data.currentStamina = 0f;
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse ShoveForward(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000a: 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)
				//IL_0019: 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)
				try
				{
					Vector3 val = ((Component)MainCamera.instance).transform.forward * 50f;
					callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3] { 0, val, 0 });
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse YankBackwards(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_000a: 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)
				//IL_0019: 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)
				try
				{
					Vector3 val = ((Component)MainCamera.instance).transform.forward * -50f;
					callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3] { 0, val, 0 });
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse MegaLaunch(ControlClient client, CrowdRequest req)
	{
		//IL_0008: 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)
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		Scene activeScene = SceneManager.GetActiveScene();
		if (((Scene)(ref activeScene)).name == "SurfaceScene")
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is not in the old world.");
		}
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(0f, 250f, 0f);
					callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3] { 0, val, 0 });
					TestMod.comments.Add("They just flew up into the air!");
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse Ragdoll(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(0f, 0f, 0f);
					callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3] { 0, val, 4f });
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse Launch(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		try
		{
			TestMod.ActionQueue.Enqueue(delegate
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					Vector3 val = default(Vector3);
					((Vector3)(ref val))..ctor(0f, 100f, 0f);
					callFunc(Player.localPlayer, "CallTakeDamageAndAddForceAndFall", new object[3] { 0, val, 0 });
					TestMod.comments.Add("They just flew up into the air!");
				}
				catch (Exception ex2)
				{
					TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex2.ToString()));
				}
			});
		}
		catch (Exception ex)
		{
			status = CrowdResponse.Status.STATUS_RETRY;
			TestMod.mls.LogInfo((object)("Crowd Control Error: " + ex.ToString()));
		}
		return new CrowdResponse(req.GetReqID(), status, message);
	}

	public static CrowdResponse Damage10(ControlClient client, CrowdRequest req)
	{
		CrowdResponse.Status status = CrowdResponse.Status.STATUS_SUCCESS;
		string message = "";
		if (Player.localPlayer.data.dead)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_FAILURE, "Player is dead.");
		}
		if (Player.localPlayer.data.isInDiveBell)
		{
			return new CrowdResponse(req.GetReqID(), CrowdResponse.Status.STATUS_RETRY);
		}
		if (Player.lo