using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LC_API.GameInterfaceAPI.Features;
using LC_API.Networking;
using MoreCompany;
using Newtonsoft.Json;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("SpringsTwitchIntegration")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("SpringsTwitchIntegration")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("724cdbfe-e650-4dd4-a64b-232e8d90cc5b")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace SpringsTwitchIntegration;

[BepInPlugin("io.springwhisper.SpringsTwitchIntegration", "String's Twitch Integration", "1.0.0")]
public class Plugin : BaseUnityPlugin
{
	private const string modGUID = "io.springwhisper.SpringsTwitchIntegration";

	private const string modName = "String's Twitch Integration";

	private const string modVersion = "1.0.0";

	private const string networkTopic = "CHAT_COMMAND";

	private readonly Harmony harmony = new Harmony("io.springwhisper.SpringsTwitchIntegration");

	public static Plugin Instance;

	public RoundManager roundManager;

	public IDictionary<string, AudioClip> audioClips = new Dictionary<string, AudioClip>();

	public SelectableLevel currentLevel;

	public EnemyVent[] currentLevelVents;

	public IDictionary<string, GameObject> spawnableObjects = new Dictionary<string, GameObject>();

	public static ManualLogSource mls;

	private void Awake()
	{
		if ((Object)(object)Instance == (Object)null)
		{
			Instance = this;
		}
		mls = Logger.CreateLogSource("io.springwhisper.SpringsTwitchIntegration");
		mls.LogInfo((object)"starting twitch integration");
		Network.RegisterAll();
		harmony.PatchAll(typeof(Plugin));
	}

	[HarmonyPatch(typeof(RoundManager), "LoadNewLevel")]
	[HarmonyPrefix]
	private static bool ModifyLevel(ref SelectableLevel newLevel)
	{
		Instance.roundManager = RoundManager.Instance;
		Instance.PopulateAudioClips();
		if (((NetworkBehaviour)Instance.roundManager).IsHost)
		{
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			foreach (GameObject val in array)
			{
				if (((Object)val).name == "Landmine")
				{
					Instance.spawnableObjects["landmine"] = val;
				}
			}
		}
		return true;
	}

	[HarmonyPatch(typeof(RoundManager), "AdvanceHourAndSpawnNewBatchOfEnemies")]
	[HarmonyPrefix]
	private static void updateCurrentLevelInfo(ref EnemyVent[] ___allEnemyVents, ref SelectableLevel ___currentLevel)
	{
		Instance.currentLevel = ___currentLevel;
		Instance.currentLevelVents = ___allEnemyVents;
	}

	public PlayerControllerB GetPlayer(string username = null)
	{
		mls.LogInfo((object)("getting player: " + username));
		if (username == null)
		{
			mls.LogInfo((object)"returning host player");
			return Instance.roundManager.playersManager.localPlayerController;
		}
		mls.LogInfo((object)"searching though nroaml player list");
		PlayerControllerB[] allPlayerScripts = Instance.roundManager.playersManager.allPlayerScripts;
		foreach (PlayerControllerB val in allPlayerScripts)
		{
			if (val.playerUsername.ToLower() == username.ToLower())
			{
				mls.LogInfo((object)("found player in normal: " + val.playerUsername));
				return val;
			}
		}
		mls.LogInfo((object)"searching though morecompany player list");
		foreach (PlayerControllerB notSupposedToExistPlayer in MainClass.notSupposedToExistPlayers)
		{
			if (notSupposedToExistPlayer.playerUsername.ToLower() == username.ToLower())
			{
				mls.LogInfo((object)("found player in morecompany: " + notSupposedToExistPlayer.playerUsername));
				return notSupposedToExistPlayer;
			}
		}
		mls.LogInfo((object)"no player found");
		return null;
	}

	public PlayerControllerB GetPlayer(ulong clientId)
	{
		mls.LogInfo((object)("getting player: " + clientId));
		PlayerControllerB[] allPlayerScripts = Instance.roundManager.playersManager.allPlayerScripts;
		foreach (PlayerControllerB val in allPlayerScripts)
		{
			mls.LogInfo((object)("checking venilla player: " + val.playerClientId));
			if (val.playerClientId == clientId)
			{
				mls.LogInfo((object)("found player: " + val.playerUsername));
				return val;
			}
		}
		mls.LogInfo((object)("checking morecompany player: " + clientId));
		foreach (PlayerControllerB notSupposedToExistPlayer in MainClass.notSupposedToExistPlayers)
		{
			mls.LogInfo((object)("checking morecompany player: " + notSupposedToExistPlayer.playerClientId));
			if (notSupposedToExistPlayer.playerClientId == clientId)
			{
				mls.LogInfo((object)("found player from morecompany: " + notSupposedToExistPlayer.playerUsername));
				return notSupposedToExistPlayer;
			}
		}
		return null;
	}

	private void PopulateAudioClips()
	{
		mls.LogInfo((object)"populating audio clips");
		if (audioClips.Count > 0)
		{
			mls.LogInfo((object)"audio clips already populated");
			return;
		}
		AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
		foreach (AudioClip val in array)
		{
			if (((Object)val).name == "Spring1" || ((Object)val).name == "Spring2" || ((Object)val).name == "Spring3")
			{
				mls.LogInfo((object)("adding audio clip: " + ((Object)val).name));
				audioClips.Add(((Object)val).name, val);
			}
		}
	}

	[NetworkMessage("CHAT_COMMAND", false)]
	private static void HandleBroadcast(ulong sender, BroadcastCommand msg)
	{
		if ((Object)(object)Instance.roundManager == (Object)null)
		{
			Instance.roundManager = RoundManager.Instance;
		}
		if (Instance.audioClips.Count == 0)
		{
			Instance.PopulateAudioClips();
		}
		mls.LogInfo((object)("received broadcast: " + msg.command + " " + msg.item + " " + msg.targetClientId));
		if (msg.command == "drop")
		{
			Instance.DropAllHeldItemsLocal(msg.targetClientId);
		}
		else if (msg.command == "fear")
		{
			Instance.FearPlayerLocal(msg.targetClientId);
		}
		else if (msg.command == "kill")
		{
			Instance.KillPlayerLocal(msg.targetClientId);
		}
		else if (msg.command == "hurt")
		{
			Instance.HurtPlayerLocal(msg.targetClientId);
		}
		else if (msg.command == "sound")
		{
			Instance.PlaySoundLocal(msg.item, msg.targetClientId);
		}
		else if (msg.command == "drunk")
		{
			Instance.MakeDrunkLocal(msg.targetClientId);
		}
	}

	public bool SpawnEnemy(string enemyName)
	{
		foreach (SpawnableEnemyWithRarity enemy in currentLevel.Enemies)
		{
			if (((Object)enemy.enemyType).name.ToLower() == enemyName.ToLower())
			{
				SpawnInsideEnemy(enemy);
				return true;
			}
		}
		foreach (SpawnableEnemyWithRarity outsideEnemy in currentLevel.OutsideEnemies)
		{
			if (((Object)outsideEnemy.enemyType).name.ToLower() == enemyName.ToLower())
			{
				SpawnOutsideEnemy(outsideEnemy);
				return true;
			}
		}
		foreach (KeyValuePair<string, GameObject> spawnableObject in spawnableObjects)
		{
			if (spawnableObject.Key.ToLower() == enemyName.ToLower())
			{
				return SpawnMine(0uL);
			}
		}
		return false;
	}

	public void SpawnInsideEnemy(SpawnableEnemyWithRarity enemy)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0041: Unknown result type (might be due to invalid IL or missing references)
		roundManager.SpawnEnemyOnServer(roundManager.allEnemyVents[Random.Range(0, roundManager.allEnemyVents.Length)].floorNode.position, roundManager.allEnemyVents[0].floorNode.eulerAngles.y, currentLevel.Enemies.IndexOf(enemy));
	}

	public void SpawnOutsideEnemy(SpawnableEnemyWithRarity enemy)
	{
		//IL_004f: 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_0059: Unknown result type (might be due to invalid IL or missing references)
		Object.Instantiate<GameObject>(currentLevel.OutsideEnemies[currentLevel.OutsideEnemies.IndexOf(enemy)].enemyType.enemyPrefab, GameObject.FindGameObjectsWithTag("OutsideAINode")[Random.Range(0, GameObject.FindGameObjectsWithTag("OutsideAINode").Length - 1)].transform.position, Quaternion.Euler(Vector3.zero)).gameObject.GetComponentInChildren<NetworkObject>().Spawn(true);
	}

	public void Wipe()
	{
		mls.LogInfo((object)"wiping");
		mls.LogInfo((object)"searching though nroaml player list");
		PlayerControllerB[] allPlayerScripts = Instance.roundManager.playersManager.allPlayerScripts;
		foreach (PlayerControllerB val in allPlayerScripts)
		{
			Instance.KillPlayer(val.playerClientId);
		}
		mls.LogInfo((object)"searching though morecompany player list");
		foreach (PlayerControllerB notSupposedToExistPlayer in MainClass.notSupposedToExistPlayers)
		{
			Instance.KillPlayer(notSupposedToExistPlayer.playerClientId);
		}
	}

	public void KillPlayer(ulong clientId)
	{
		mls.LogInfo((object)"broadcasting kill command");
		BroadcastCommand broadcastCommand = new BroadcastCommand("kill", null, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
		KillPlayerLocal(clientId);
	}

	public void KillPlayerLocal(ulong clientId)
	{
		//IL_0046: Unknown result type (might be due to invalid IL or missing references)
		mls.LogInfo((object)("attempting to killing player: " + clientId));
		PlayerControllerB player = GetPlayer(clientId);
		if (((NetworkBehaviour)player).IsOwner)
		{
			mls.LogInfo((object)("killing local player: " + player.playerUsername));
			player.KillPlayer(Vector3.zero, true, (CauseOfDeath)0, 1);
		}
	}

	public bool GiveItem(string itemName, string username = null)
	{
		PlayerControllerB player = GetPlayer(username);
		Player orAdd = Player.GetOrAdd(player);
		if ((Object)(object)player != (Object)null)
		{
			Item val = Item.CreateAndGiveItem(itemName, orAdd, true, false);
			if ((Object)(object)val.GrabbableObject.playerHeldBy != (Object)(object)player)
			{
				mls.LogInfo((object)"item not held by player, correcting");
				val.GrabbableObject.playerHeldBy = player;
			}
			return true;
		}
		return false;
	}

	public void HurtPlayer(ulong clientId)
	{
		mls.LogInfo((object)"broadcasting hurt command");
		BroadcastCommand broadcastCommand = new BroadcastCommand("hurt", null, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
		HurtPlayerLocal(clientId);
	}

	public void HurtPlayerLocal(ulong clientId)
	{
		//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)
		PlayerControllerB player = GetPlayer(clientId);
		if (((NetworkBehaviour)player).IsOwner)
		{
			mls.LogInfo((object)("hurting local player: " + player.playerUsername));
			player.DamagePlayer(40, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
		}
	}

	public void FearPlayer(ulong clientId)
	{
		mls.LogInfo((object)"broadcasting fear command");
		BroadcastCommand broadcastCommand = new BroadcastCommand("fear", null, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
		FearPlayerLocal(clientId);
	}

	public void FearPlayerLocal(ulong clientId)
	{
		PlayerControllerB player = GetPlayer(clientId);
		if (((NetworkBehaviour)player).IsOwner)
		{
			mls.LogInfo((object)("fearing " + player.playerUsername));
			player.JumpToFearLevel(1f, true);
		}
	}

	public void DropAllHeldItems(ulong clientId)
	{
		mls.LogInfo((object)"broadcasting drop command");
		BroadcastCommand broadcastCommand = new BroadcastCommand("drop", null, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
		DropAllHeldItemsLocal(clientId);
	}

	private void DropAllHeldItemsLocal(ulong clientId)
	{
		mls.LogInfo((object)("dropping all items locally for player: " + clientId));
		PlayerControllerB player = Instance.GetPlayer(clientId);
		if (((NetworkBehaviour)player).IsOwner)
		{
			mls.LogInfo((object)"player is owner, dropping all items");
			player.DropAllHeldItemsAndSync();
		}
	}

	public void PlaySound(string soundName, ulong clientId)
	{
		mls.LogInfo((object)"broadcasting sound command");
		BroadcastCommand broadcastCommand = new BroadcastCommand("sound", soundName, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
		PlaySoundLocal(soundName, clientId);
	}

	public void PlaySoundLocal(string soundName, ulong clientId)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0077: Unknown result type (might be due to invalid IL or missing references)
		//IL_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Expected O, but got Unknown
		mls.LogInfo((object)("playing sound locally: " + soundName));
		PlayerControllerB player = Instance.GetPlayer(clientId);
		if (((NetworkBehaviour)player).IsOwner && Instance.audioClips.ContainsKey(soundName))
		{
			mls.LogInfo((object)("found sound clip: " + soundName));
			AudioClip val = Instance.audioClips[soundName];
			GameObject val2 = new GameObject("SoundPlayer");
			Vector3 position = ((Component)player).transform.position;
			position.y += 1f;
			position.z += 1f;
			val2.transform.position = position;
			AudioSource obj = val2.AddComponent<AudioSource>();
			obj.clip = val;
			obj.spatialBlend = 1f;
			obj.volume = 10f;
			obj.Play();
			Object.Destroy((Object)val2, val.length);
		}
		else
		{
			mls.LogInfo((object)("sound clip not found: " + soundName));
		}
	}

	public void MakeDrunk(ulong clientId)
	{
		mls.LogInfo((object)("making player drunk: " + clientId));
		MakeDrunkLocal(clientId);
		BroadcastCommand broadcastCommand = new BroadcastCommand("drunk", null, clientId);
		Network.Broadcast<BroadcastCommand>("CHAT_COMMAND", broadcastCommand);
	}

	public void MakeDrunkLocal(ulong clientId)
	{
		mls.LogInfo((object)("making player drunk locally: " + clientId));
		PlayerControllerB player = Instance.GetPlayer(clientId);
		if ((Object)(object)player != (Object)null)
		{
			player.drunkness = 20f;
		}
	}

	public bool SpawnMine(ulong clientId)
	{
		//IL_0028: Unknown result type (might be due to invalid IL or missing references)
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		//IL_0070: Unknown result type (might be due to invalid IL or missing references)
		PlayerControllerB player = Instance.GetPlayer(clientId);
		if ((Object)(object)player != (Object)null)
		{
			Vector3 val = Instance.roundManager.RandomlyOffsetPosition(((Component)player).transform.position, 10f, 4f);
			if (val != ((Component)player).transform.position)
			{
				try
				{
					Object.Instantiate<GameObject>(spawnableObjects["landmine"], val, Quaternion.Euler(0f, 0f, 0f)).GetComponent<NetworkObject>().Spawn(true);
					return true;
				}
				catch (Exception ex)
				{
					mls.LogError((object)("error spawning mine: " + ex.Message));
					return false;
				}
			}
		}
		return false;
	}
}
public class BroadcastCommand
{
	public string command;

	public string item;

	public ulong targetClientId;

	public BroadcastCommand(string command, string item, ulong targetClientId)
	{
		this.command = command;
		this.item = item;
		this.targetClientId = targetClientId;
	}
}
public class ServerCommand
{
	public string command;

	public string item;

	public string user;

	public string from_user;

	public string channel;

	public ServerCommand(string command, string item, string user, string from_user, string channel)
	{
		this.command = command;
		this.item = item;
		this.user = user;
		this.from_user = from_user;
		this.channel = channel;
	}

	public ServerCommandResponse ToResponse(bool success, string data)
	{
		return ServerCommandResponse.FromServerCommand(this, success, data);
	}
}
public class ServerCommandResponse
{
	public string command;

	public string item;

	public string user;

	public string from_user;

	public string channel;

	public bool success;

	public string data;

	public ServerCommandResponse(string command, string item, string user, string from_user, string channel, bool success, string data)
	{
		this.command = command;
		this.item = item;
		this.user = user;
		this.from_user = from_user;
		this.channel = channel;
		this.success = success;
		this.data = data;
	}

	public static ServerCommandResponse FromServerCommand(ServerCommand command, bool success, string data)
	{
		return new ServerCommandResponse(command.command, command.item, command.user, command.from_user, command.channel, success, data);
	}
}
public class WebSocketManager
{
	private ManualLogSource mls;

	private Uri uri;

	private ClientWebSocket webSocket;

	private WebSocketManager(ManualLogSource mls, string url)
	{
		this.mls = mls;
		uri = new Uri(url);
		webSocket = new ClientWebSocket();
	}

	public static async void Connect(string url, ManualLogSource mls)
	{
		WebSocketManager webSocket = new WebSocketManager(mls, url);
		while (true)
		{
			try
			{
				webSocket.webSocket = new ClientWebSocket();
				webSocket.mls.LogInfo((object)("connecting to " + url));
				int millisecondsDelay = 5000;
				CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(millisecondsDelay);
				Task connectTask = webSocket.webSocket.ConnectAsync(webSocket.uri, cancellationTokenSource.Token);
				if (await Task.WhenAny(new Task[2]
				{
					connectTask,
					Task.Delay(millisecondsDelay, cancellationTokenSource.Token)
				}) == connectTask)
				{
					if (webSocket.webSocket.State == WebSocketState.Open)
					{
						webSocket.mls.LogInfo((object)"connected");
						await webSocket.ReceiveMessageLoop();
					}
				}
				else
				{
					webSocket.mls.LogInfo((object)"connection failed...");
				}
			}
			catch
			{
				webSocket.mls.LogInfo((object)"websocket failed.");
			}
			await Task.Delay(TimeSpan.FromSeconds(1.0));
			webSocket.mls.LogInfo((object)"websocket disconnected, reconnecting...");
		}
	}

	public async Task ReceiveMessageLoop()
	{
		mls.LogInfo((object)"starting receive loop");
		while (webSocket.State == WebSocketState.Open)
		{
			try
			{
				byte[] buffer = new byte[1024];
				WebSocketReceiveResult webSocketReceiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
				string @string = Encoding.UTF8.GetString(buffer, 0, webSocketReceiveResult.Count);
				mls.LogInfo((object)("got msg: " + @string));
				ServerCommand serverCommand = JsonConvert.DeserializeObject<ServerCommand>(@string);
				if (serverCommand.command == "kill")
				{
					PlayerControllerB player = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player != (Object)null)
					{
						Plugin.Instance.KillPlayer(player.playerClientId);
						ServerCommandResponse resp = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp);
					}
				}
				else if (serverCommand.command == "wipe")
				{
					Plugin.Instance.Wipe();
					ServerCommandResponse resp2 = serverCommand.ToResponse(success: true, null);
					await SendMsg(resp2);
				}
				else if (serverCommand.command == "give")
				{
					if (Plugin.Instance.GiveItem(serverCommand.item, serverCommand.user))
					{
						ServerCommandResponse resp3 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp3);
					}
				}
				else if (serverCommand.command == "spawn")
				{
					if (Plugin.Instance.SpawnEnemy(serverCommand.item))
					{
						ServerCommandResponse resp4 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp4);
					}
				}
				else if (serverCommand.command == "fear")
				{
					PlayerControllerB player2 = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player2 != (Object)null)
					{
						Plugin.Instance.FearPlayer(player2.playerClientId);
						ServerCommandResponse resp5 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp5);
					}
				}
				else if (serverCommand.command == "drunk")
				{
					PlayerControllerB player3 = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player3 != (Object)null)
					{
						Plugin.Instance.MakeDrunk(player3.playerClientId);
						ServerCommandResponse resp6 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp6);
					}
				}
				else if (serverCommand.command == "drop")
				{
					PlayerControllerB player4 = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player4 != (Object)null)
					{
						player4.DropAllHeldItems(true, false);
						Plugin.Instance.DropAllHeldItems(player4.playerClientId);
						ServerCommandResponse resp7 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp7);
					}
				}
				else if (serverCommand.command == "hurt")
				{
					PlayerControllerB player5 = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player5 != (Object)null)
					{
						Plugin.Instance.HurtPlayer(player5.playerClientId);
						ServerCommandResponse resp8 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp8);
					}
				}
				else if (serverCommand.command == "sound")
				{
					PlayerControllerB player6 = Plugin.Instance.GetPlayer(serverCommand.user);
					if ((Object)(object)player6 != (Object)null)
					{
						Plugin.Instance.PlaySound("Spring1", player6.playerClientId);
						ServerCommandResponse resp9 = serverCommand.ToResponse(success: true, null);
						await SendMsg(resp9);
					}
				}
				else if (serverCommand.command == "lightsout")
				{
					Object.FindObjectOfType<ShipLights>().SetShipLightsBoolean(false);
					ServerCommandResponse resp10 = serverCommand.ToResponse(success: true, null);
					await SendMsg(resp10);
				}
				else if (serverCommand.command == "listplayers")
				{
					List<string> list = new List<string>();
					foreach (Player active in Player.ActiveList)
					{
						list.Add(active.PlayerController.playerUsername);
						mls.LogInfo((object)("vanilla players: " + active.PlayerController.playerUsername));
					}
					foreach (PlayerControllerB notSupposedToExistPlayer in MainClass.notSupposedToExistPlayers)
					{
						list.Add(notSupposedToExistPlayer.playerUsername);
						mls.LogInfo((object)("morecompany players: " + notSupposedToExistPlayer.playerUsername));
					}
					ServerCommandResponse resp11 = serverCommand.ToResponse(success: true, string.Join(", ", list));
					await SendMsg(resp11);
				}
				else if (serverCommand.command == "listenemies")
				{
					foreach (SpawnableEnemyWithRarity enemy in Plugin.Instance.currentLevel.Enemies)
					{
						mls.LogInfo((object)("inside enemies: " + ((Object)enemy.enemyType).name.ToLower()));
					}
					foreach (SpawnableEnemyWithRarity outsideEnemy in Plugin.Instance.currentLevel.OutsideEnemies)
					{
						mls.LogInfo((object)("outside enemies: " + ((Object)outsideEnemy.enemyType).name.ToLower()));
					}
				}
				else if (serverCommand.command == "listitems")
				{
					foreach (Item items in Plugin.Instance.roundManager.playersManager.allItemsList.itemsList)
					{
						mls.LogInfo((object)("item: " + items.itemName.ToLower()));
					}
				}
				else if (serverCommand.command == "listaudio")
				{
					AudioClip[] array = Resources.FindObjectsOfTypeAll<AudioClip>();
					foreach (AudioClip val in array)
					{
						mls.LogInfo((object)("audio clip: " + ((Object)val).name));
					}
				}
			}
			catch (Exception ex)
			{
				mls.LogError((object)("error: " + ex));
			}
		}
	}

	private async Task SendMsg(ServerCommandResponse resp)
	{
		ArraySegment<byte> buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject((object)resp)));
		await webSocket.SendAsync(buffer, WebSocketMessageType.Text, endOfMessage: true, CancellationToken.None);
	}
}