using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using HostFixes.UI;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using Netcode.Transports.Facepunch;
using Steamworks;
using Steamworks.Data;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("CharlesE2")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Lethal Company server-side anticheat mod.")]
[assembly: AssemblyFileVersion("1.0.21.0")]
[assembly: AssemblyInformationalVersion("1.0.21+86b602b2c115d0edcc3810b56dbd1d15d4496b2d")]
[assembly: AssemblyProduct("Host Fixes")]
[assembly: AssemblyTitle("com.github.CharlesE2.HostFixes")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Charlese2/HostFixes")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.21.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace HostFixes
{
	internal class Patches
	{
		[HarmonyPatch(typeof(StartOfRound), "SyncShipUnlockablesServerRpc")]
		internal static class Fix_SyncShipUnlockablesServerRpc_Crash
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				bool flag = false;
				int num = -1;
				List<CodeInstruction> list = new List<CodeInstruction>(instructions);
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].opcode == OpCodes.Call && list[i].operand is MethodInfo methodInfo && methodInfo.Name == "FindObjectsOfType")
					{
						num = i;
						flag = true;
						break;
					}
				}
				if (flag)
				{
					list.Insert(num + 1, Transpilers.EmitDelegate<Func<IEnumerable<PlaceableShipObject>, IEnumerable<PlaceableShipObject>>>((Func<IEnumerable<PlaceableShipObject>, IEnumerable<PlaceableShipObject>>)((IEnumerable<PlaceableShipObject> placeableShipObjects) => placeableShipObjects.Where((PlaceableShipObject placeableShipObject) => (Object)(object)placeableShipObject.parentObject != (Object)null))));
				}
				else
				{
					Plugin.Log.LogWarning((object)"Could not patch SyncShipUnlockablesServerRpc's Crash");
				}
				return list.AsEnumerable();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SyncAlreadyHeldObjectsServerRpc")]
		internal static class SyncAlreadyHeldObjects_NullRef
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected O, but got Unknown
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Expected O, but got Unknown
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(GrabbableObject), "isHeld"), (string)null)
				});
				if (!val.ReportFailure(MethodBase.GetCurrentMethod(), (Action<string>)Plugin.Log.LogWarning))
				{
					val.SetOperandAndAdvance((object)AccessTools.Field(typeof(GrabbableObject), "playerHeldBy"));
					val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
					{
						new CodeInstruction(OpCodes.Ldnull, (object)null),
						new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(Object), "op_Inequality", (Type[])null, (Type[])null))
					});
				}
				return val.InstructionEnumeration();
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "SyncAlreadyHeldObjectsClientRpc")]
		internal static class SyncAlreadyHeldObjectsToCallingClient
		{
			public static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_0080: Expected O, but got Unknown
				bool flag = false;
				int num = -1;
				List<CodeInstruction> list = new List<CodeInstruction>(instructions);
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].opcode == OpCodes.Call && list[i].operand is MethodInfo methodInfo && methodInfo.Name == "__beginSendClientRpc")
					{
						num = i;
						flag = true;
						break;
					}
				}
				if (flag)
				{
					list.Insert(num - 1, new CodeInstruction(OpCodes.Ldarg, (object)5));
					list.Insert(num, Transpilers.EmitDelegate<Func<ClientRpcParams, ulong, ClientRpcParams>>((Func<ClientRpcParams, ulong, ClientRpcParams>)delegate(ClientRpcParams clientRpcParams, ulong senderClientId)
					{
						//IL_0002: Unknown result type (might be due to invalid IL or missing references)
						//IL_000c: 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_0020: Unknown result type (might be due to invalid IL or missing references)
						//IL_0025: Unknown result type (might be due to invalid IL or missing references)
						//IL_0026: Unknown result type (might be due to invalid IL or missing references)
						//IL_0027: Unknown result type (might be due to invalid IL or missing references)
						ClientRpcParams val = default(ClientRpcParams);
						val.Send = new ClientRpcSendParams
						{
							TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
						};
						return clientRpcParams = val;
					}));
				}
				else
				{
					Plugin.Log.LogWarning((object)"Could not patch SyncAlreadyHeldObjectsClientRpc");
				}
				return list.AsEnumerable();
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(FacepunchTransport), "Steamworks.ISocketManager.OnConnecting")]
		private class Identity_Fix
		{
			public static void Prefix(ref Connection connection, ref ConnectionInfo info)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				Plugin.SteamIdtoConnectionIdMap[((NetIdentity)(ref info.identity)).SteamId.Value] = ((Connection)(ref connection)).Id;
				Plugin.ConnectionIdtoSteamIdMap[((Connection)(ref connection)).Id] = ((NetIdentity)(ref info.identity)).SteamId.Value;
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(FacepunchTransport), "Steamworks.ISocketManager.OnDisconnected")]
		private class SteamIdDictionary_Cleanup
		{
			public static void Prefix(ref Connection connection, ref ConnectionInfo info)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				NetworkManager singleton = NetworkManager.Singleton;
				if (singleton != null && singleton.IsListening)
				{
					Plugin.SteamIdtoConnectionIdMap.Remove(((NetIdentity)(ref info.identity)).SteamId.Value);
					Plugin.ConnectionIdtoSteamIdMap.Remove(((Connection)(ref connection)).Id);
					Plugin.playerSteamNames.Remove(((NetIdentity)(ref info.identity)).SteamId.Value);
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(NetworkConnectionManager), "OnClientDisconnectFromServer")]
		private class ClientIdToSteamId_Cleanup
		{
			public static void Prefix(ulong clientId)
			{
				if (NetworkManager.Singleton.IsHost && Plugin.ClientIdToSteamIdMap.TryGetValue(clientId, out var value))
				{
					Plugin.SteamIdtoClientIdMap.Remove(value);
					Plugin.ClientIdToSteamIdMap.Remove(clientId);
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(StartOfRound), "OnClientConnect")]
		private class OnClientConnect
		{
			public static void Postfix(StartOfRound __instance, ulong clientId)
			{
				if (((NetworkBehaviour)__instance).IsServer && clientId != 0L && !GameNetworkManager.Instance.disableSteam && StartOfRound.Instance.ClientPlayerList.TryGetValue(clientId, out var value))
				{
					StartOfRound.Instance.allPlayerScripts[value].playerSteamId = Plugin.ClientIdToSteamIdMap[clientId];
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(GameNetworkManager), "ConnectionApproval")]
		private class MapSteamIdToClientId
		{
			public static void Postfix(GameNetworkManager __instance, ref ConnectionApprovalRequest request, ref ConnectionApprovalResponse response)
			{
				if (__instance.disableSteam)
				{
					return;
				}
				ulong num = NetworkManager.Singleton.ConnectionManager.ClientIdToTransportId(request.ClientNetworkId);
				if (Plugin.ConnectionIdtoSteamIdMap.TryGetValue((uint)num, out var value))
				{
					Plugin.SteamIdtoClientIdMap[value] = request.ClientNetworkId;
					Plugin.ClientIdToSteamIdMap[request.ClientNetworkId] = value;
					StartOfRound instance = StartOfRound.Instance;
					if (instance != null && instance.KickedClientIds.Contains(value))
					{
						if (response.Reason == "")
						{
							response.Reason = "You cannot rejoin after being kicked.";
						}
						response.Approved = false;
					}
					string[] array = Encoding.ASCII.GetString(request.Payload).Split(",");
					if (array.Length >= 2 && array[1] != value.ToString())
					{
						Plugin.Log.LogInfo((object)$"SteamID sent by client ({array[1]}) doesn't match SteamID from steam ({value}).");
					}
				}
				else
				{
					Plugin.Log.LogError((object)$"[ConnectionApproval] Could not get steamId from transportId ({num})");
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(Terminal), "Awake")]
		private class HostInitialization
		{
			public static void Postfix(Terminal __instance)
			{
				((MonoBehaviour)Plugin.Instance).StartCoroutine(Plugin.TerminalAwakeWait(__instance));
				new InfoPanel();
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(NetworkConnectionManager), "Initialize")]
		private class SetupIdMap
		{
			public static void Prefix()
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				if (!GameNetworkManager.Instance.disableSteam)
				{
					Plugin.SteamIdtoClientIdMap[SteamId.op_Implicit(SteamClient.SteamId)] = 0uL;
					Plugin.ClientIdToSteamIdMap[0uL] = SteamId.op_Implicit(SteamClient.SteamId);
					Plugin.SteamIdtoConnectionIdMap[SteamId.op_Implicit(SteamClient.SteamId)] = 0u;
					Plugin.ConnectionIdtoSteamIdMap[0u] = SteamId.op_Implicit(SteamClient.SteamId);
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(NetworkManager), "OnEnable")]
		private class RegisterNetworkManagerEvents
		{
			public static void Postfix()
			{
				NetworkManager.Singleton.OnServerStopped -= Plugin.ServerStopped;
				NetworkManager.Singleton.OnServerStopped += Plugin.ServerStopped;
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(HUDManager), "AddPlayerChatMessageClientRpc")]
		private class AddPlayerChatMessageClientRpc_Patch
		{
			public static bool Prefix(HUDManager __instance, int playerId)
			{
				NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
				if ((Object)(object)networkManager == (Object)null || !networkManager.IsListening)
				{
					return false;
				}
				if (!networkManager.IsHost && (playerId < 0 || playerId >= StartOfRound.Instance.allPlayerScripts.Length))
				{
					return false;
				}
				return true;
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
		private class SwitchToItemSlot_Patch
		{
			public static void Prefix(PlayerControllerB __instance, ref int slot)
			{
				slot = Mathf.Clamp(slot, 0, __instance.ItemSlots.Length - 1);
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(PlayerControllerB), "NextItemSlot")]
		private class NextItemSlot_Patch
		{
			public static void Prefix(PlayerControllerB __instance)
			{
				__instance.currentItemSlot = Mathf.Clamp(__instance.currentItemSlot, 0, __instance.ItemSlots.Length - 1);
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(StartOfRound), "OnPlayerDC")]
		private class OnPlayerDC_Patch
		{
			public static void Postfix(ulong clientId)
			{
				if (Plugin.votedToLeaveEarlyPlayers.Remove(clientId))
				{
					TimeOfDay.Instance.votesForShipToLeaveEarly = Plugin.votedToLeaveEarlyPlayers.Count;
				}
			}
		}

		[HarmonyWrapSafe]
		[HarmonyPatch(typeof(StartOfRound), "ShipLeave")]
		private class ShipLeave_Patch
		{
			public static void Prefix()
			{
				Plugin.votedToLeaveEarlyPlayers.Clear();
			}
		}
	}
	[BepInPlugin("com.github.CharlesE2.HostFixes", "Host Fixes", "1.0.21")]
	public class Plugin : BaseUnityPlugin
	{
		internal class ConnectionEvents
		{
			internal static void ConnectionAttempt(Lobby _, Friend member)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: 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)
				if (NetworkManager.Singleton.IsHost && !playerSteamNames.TryAdd(member.Id.Value, ((Friend)(ref member)).Name))
				{
					Log.LogWarning((object)$"SteamId: ({member.Id.Value}) Name: ({((Friend)(ref member)).Name}) is already in the playerSteamNames list.");
				}
			}

			internal static void ConnectionCleanup(Lobby _, Friend member)
			{
				//IL_0016: 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_0021: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				if (NetworkManager.Singleton.IsHost && !GameNetworkManager.Instance.steamIdsInLobby.Remove(SteamId.op_Implicit(member.Id.Value)))
				{
					Log.LogWarning((object)$"({member.Id.Value}) already removed from steamIdsInLobby.");
				}
			}

			internal static void LobbyCreated(Result result, Lobby lobby)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_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)
				if ((int)result == 1)
				{
					Dictionary<ulong, string> playerSteamNames = Plugin.playerSteamNames;
					ulong value = ((Lobby)(ref lobby)).Owner.Id.Value;
					Friend owner = ((Lobby)(ref lobby)).Owner;
					if (!playerSteamNames.TryAdd(value, ((Friend)(ref owner)).Name))
					{
						Log.LogWarning((object)"Host is already in playerSteamNames.");
					}
				}
			}
		}

		public class HostFixesServerReceiveRpcs
		{
			public void BuyItemsServerRpc(int[] boughtItems, int newGroupCredits, int numItemsInShip, Terminal instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: 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_00b0: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Unknown result type (might be due to invalid IL or missing references)
				//IL_011d: Unknown result type (might be due to invalid IL or missing references)
				//IL_011f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0126: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0215: Unknown result type (might be due to invalid IL or missing references)
				//IL_021f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0259: Unknown result type (might be due to invalid IL or missing references)
				//IL_0301: Unknown result type (might be due to invalid IL or missing references)
				//IL_030b: Unknown result type (might be due to invalid IL or missing references)
				//IL_031e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0327: Unknown result type (might be due to invalid IL or missing references)
				//IL_0345: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[BuyItemsServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configCheckPrices.Value)
				{
					instance.BuyItemsServerRpc(boughtItems, newGroupCredits, numItemsInShip);
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				int num = 0;
				if (instance.numberOfItemsInDropship + boughtItems.Length > 12)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to buy too many items.");
					ClientRpcParams val = default(ClientRpcParams);
					val.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams = val;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(instance.groupCredits, instance.numberOfItemsInDropship, instance.hasWarrantyTicket, instance, clientRpcParams);
					return;
				}
				if (newGroupCredits < 0)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried tried to set credits to a negative number while buying items.");
					ClientRpcParams val = default(ClientRpcParams);
					val.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams2 = val;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(instance.groupCredits, instance.numberOfItemsInDropship, instance.hasWarrantyTicket, instance, clientRpcParams2);
					return;
				}
				Dictionary<int, int> dictionary = (from item in boughtItems
					group item by item).ToDictionary((IGrouping<int, int> item) => item.Key, (IGrouping<int, int> item) => item.Count());
				foreach (int key in dictionary.Keys)
				{
					if (key < 0 || key >= instance.buyableItemsList.Length || key >= instance.itemSalesPercentages.Length)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to buy an item that was not in the host's shop. Item #{key}");
						ClientRpcParams val = default(ClientRpcParams);
						val.Send = new ClientRpcSendParams
						{
							TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
						};
						ClientRpcParams clientRpcParams3 = val;
						HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(instance.groupCredits, instance.numberOfItemsInDropship, instance.hasWarrantyTicket, instance, clientRpcParams3);
						return;
					}
					num += (int)((float)instance.buyableItemsList[key].creditsWorth * ((float)instance.itemSalesPercentages[key] / 100f) * (float)dictionary[key]);
				}
				if (instance.groupCredits - num != newGroupCredits)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) credits spent on items does not match item price. " + $"Spent credits: {instance.groupCredits - newGroupCredits} Cost Of items: {num}"));
					ClientRpcParams val = default(ClientRpcParams);
					val.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams4 = val;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(instance.groupCredits, instance.numberOfItemsInDropship, instance.hasWarrantyTicket, instance, clientRpcParams4);
				}
				else
				{
					instance.BuyItemsServerRpc(boughtItems, newGroupCredits, numItemsInShip);
				}
			}

			public void PlayTerminalAudioServerRpc(int clipIndex, Terminal instance, ServerRpcParams _)
			{
				if (!terminalSoundPlaying)
				{
					((MonoBehaviour)Instance).StartCoroutine(TerminalSoundCooldown());
					instance.PlayTerminalAudioServerRpc(clipIndex);
				}
			}

			public void BuyShipUnlockableServerRpc(int unlockableID, int newGroupCreditsAmount, StartOfRound instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[BuyShipUnlockableServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				Terminal val = Object.FindObjectOfType<Terminal>();
				if (senderClientId == 0L)
				{
					instance.BuyShipUnlockableServerRpc(unlockableID, newGroupCreditsAmount);
				}
				else if (!buyShipUnlockableOnCooldown)
				{
					((MonoBehaviour)Instance).StartCoroutine(BuyShipUnlockableCooldown());
					string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
					int value2;
					if (unlockableID < 0 || unlockableID >= StartOfRound.Instance.unlockablesList.unlockables.Count)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to buy unlockable that is not in the unlockables list. ({unlockableID}).");
					}
					else if (StartOfRound.Instance.unlockablesList.unlockables[unlockableID].alreadyUnlocked)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to unlock an unlockable multiple times");
					}
					else if (!unlockablePrices.TryGetValue(unlockableID, out value2))
					{
						Log.LogError((object)$"Could not find price of ship unlockable #{unlockableID}");
					}
					else if (newGroupCreditsAmount < 0)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried tried to set credits to a negative number unlocking ship unlockable.");
					}
					else if (senderClientId != 0L && val.groupCredits - value2 != newGroupCreditsAmount)
					{
						Log.LogInfo((object)($"Player #{value} ({playerUsername}) calculated credit amount does not match sent credit amount for unlockable. " + $"Current credits: {val.groupCredits} Unlockable cost: {value2} Sent credit Amount: {newGroupCreditsAmount}"));
					}
					else if (newGroupCreditsAmount < val.groupCredits)
					{
						instance.BuyShipUnlockableServerRpc(unlockableID, newGroupCreditsAmount);
					}
					else
					{
						Log.LogInfo((object)($"Player #{senderClientId} ({playerUsername}) attempted to increase credits while buying ship unlockables." + $" Attempted credit value: {newGroupCreditsAmount} Old credit value: {val.groupCredits}"));
					}
				}
			}

			public void ChangeLevelServerRpc(int levelID, int newGroupCreditsAmount, StartOfRound instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0355: Unknown result type (might be due to invalid IL or missing references)
				//IL_035f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0372: Unknown result type (might be due to invalid IL or missing references)
				//IL_0374: Unknown result type (might be due to invalid IL or missing references)
				//IL_0379: Unknown result type (might be due to invalid IL or missing references)
				//IL_037b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0399: Unknown result type (might be due to invalid IL or missing references)
				//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0409: Unknown result type (might be due to invalid IL or missing references)
				//IL_040b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0410: Unknown result type (might be due to invalid IL or missing references)
				//IL_0412: Unknown result type (might be due to invalid IL or missing references)
				//IL_0430: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ChangeLevelServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				if (changeLevelCooldown.TryGetValue(value, out var value2) && value2)
				{
					return;
				}
				((MonoBehaviour)Instance).StartCoroutine(ChangeLevelCooldown(value));
				if (senderClientId == 0L)
				{
					instance.ChangeLevelServerRpc(levelID, newGroupCreditsAmount);
					return;
				}
				Terminal val = Object.FindObjectOfType<Terminal>();
				if (StartOfRound.Instance.allPlayerScripts[value].isPlayerDead)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to change the moon while they are dead on the server.");
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams = val2;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(val.groupCredits, val.numberOfItemsInDropship, val.hasWarrantyTicket, val, clientRpcParams);
					return;
				}
				if (newGroupCreditsAmount < 0)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to set credits to a negative number while changing levels.");
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams2 = val2;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(val.groupCredits, val.numberOfItemsInDropship, val.hasWarrantyTicket, val, clientRpcParams2);
					return;
				}
				if (!configCheckPrices.Value)
				{
					instance.ChangeLevelServerRpc(levelID, newGroupCreditsAmount);
					return;
				}
				if (moons.Count == 0)
				{
					moons = (from moon in val.terminalNodes.allKeywords.First((TerminalKeyword keyword) => ((Object)keyword).name == "Route").compatibleNouns
						group moon by moon.noun into moon
						select moon.First() into moon
						select moon.result.terminalOptions.First((CompatibleNoun option) => ((Object)option.noun).name == "Confirm")).ToDictionary((CompatibleNoun option) => option.result.buyRerouteToMoon, (CompatibleNoun option) => option.result.itemCost);
				}
				if (!moons.ContainsKey(levelID))
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent levelID ({levelID}) that is not in the moons array.");
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams3 = val2;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(val.groupCredits, val.numberOfItemsInDropship, val.hasWarrantyTicket, val, clientRpcParams3);
					return;
				}
				int num = moons[levelID];
				if (val.groupCredits - num != newGroupCreditsAmount)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) calculated credit amount does not match sent credit amount for moon. " + $"Spent credits: {val.groupCredits - newGroupCreditsAmount} Moon cost: {num}"));
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams4 = val2;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(val.groupCredits, val.numberOfItemsInDropship, val.hasWarrantyTicket, val, clientRpcParams4);
				}
				else if (newGroupCreditsAmount > val.groupCredits)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) attempted to increase credits by changing levels. " + $"Attempted Credit Value: {newGroupCreditsAmount} Old Credit Value: {val.groupCredits}"));
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams5 = val2;
					HostFixesServerSendRpcs.Instance.SyncTerminalValuesClientRpc(val.groupCredits, val.numberOfItemsInDropship, val.hasWarrantyTicket, val, clientRpcParams5);
				}
				else
				{
					instance.ChangeLevelServerRpc(levelID, newGroupCreditsAmount);
				}
			}

			public void AddPlayerChatMessageServerRpc(string chatMessage, int playerId, HUDManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				if (string.IsNullOrWhiteSpace(chatMessage))
				{
					return;
				}
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)($"[AddPlayerChatMessageServerRpc] Failed to get the playerId from senderClientId: ({senderClientId}) " + "Message: (" + chatMessage + ")"));
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				if (StartOfRound.Instance.allPlayerScripts[value].isPlayerDead)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) tried sending a chat message while they are dead on the server. " + "Message: (" + chatMessage + ")"));
					return;
				}
				if (playerId < 0 || playerId >= StartOfRound.Instance.allPlayerScripts.Length)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) tried to chat with a playerId ({playerId}) that is not a valid player. " + "Message: (" + chatMessage + ")"));
					return;
				}
				string text = Regex.Replace(chatMessage, "<(\\S+?)>", "($+)");
				if (string.IsNullOrWhiteSpace(text))
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) Chat message was empty after sanitization. Original Message: ({chatMessage})");
					return;
				}
				if (playerId == value)
				{
					instance.AddPlayerChatMessageServerRpc(text, playerId);
					return;
				}
				Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to send message as another player #({playerId}) Message: ({chatMessage})");
			}

			public void AddTextMessageServerRpc(string chatMessage, HUDManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[AddTextMessageServerRpc] Failed to get the playerId from senderClientId: ({senderClientId}) Message: ({chatMessage})");
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				ulong playerSteamId = StartOfRound.Instance.allPlayerScripts[value].playerSteamId;
				if (GameNetworkManager.Instance.disableSteam)
				{
					HUDManager.Instance.AddTextMessageServerRpc(chatMessage);
				}
				else if (!chatMessage.EndsWith(" started the ship."))
				{
					if (!playerSteamNames.TryGetValue(playerSteamId, out string value2))
					{
						Log.LogError((object)$"Failed to get steam username from playerlist for steamId: {playerSteamId} Message: ({chatMessage})");
					}
					else if (senderClientId == 0L || chatMessage.Equals(playerUsername + " joined the ship.") || chatMessage.Equals(value2 + " joined the ship.") || chatMessage.Equals(value2 + "... joined the ship.") || chatMessage.Equals(playerUsername + " was left behind.") || chatMessage.StartsWith($"[morecompanycosmetics];{value};"))
					{
						instance.AddTextMessageServerRpc(chatMessage);
					}
					else
					{
						Log.LogInfo((object)$"Player #{value} ({value2}) tried to send message as the server: ({chatMessage})");
					}
				}
			}

			public void SetShipLeaveEarlyServerRpc(TimeOfDay instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[SetShipLeaveEarlyServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
				}
				else if (!votedToLeaveEarlyPlayers.Contains(senderClientId) && StartOfRound.Instance.allPlayerScripts[value].isPlayerDead)
				{
					votedToLeaveEarlyPlayers.Add(senderClientId);
					int val = StartOfRound.Instance.connectedPlayersAmount + 1 - StartOfRound.Instance.livingPlayers;
					if (votedToLeaveEarlyPlayers.Count >= Math.Max(val, configMinimumVotesToLeaveEarly.Value))
					{
						instance.votesForShipToLeaveEarly = votedToLeaveEarlyPlayers.Count;
						instance.SetShipLeaveEarlyClientRpc(instance.normalizedTimeOfDay + 0.1f, instance.votesForShipToLeaveEarly);
					}
					else
					{
						instance.votesForShipToLeaveEarly++;
						instance.AddVoteForShipToLeaveEarlyClientRpc();
					}
				}
				else
				{
					string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to force the vote to leave.");
				}
			}

			public void PlaceShipObjectServerRpc(Vector3 newPosition, Vector3 newRotation, NetworkObjectReference objectRef, int playerWhoMoved, ShipBuildModeManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Unknown result type (might be due to invalid IL or missing references)
				//IL_0256: Unknown result type (might be due to invalid IL or missing references)
				//IL_025a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_0288: Unknown result type (might be due to invalid IL or missing references)
				//IL_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_028a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0210: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_0358: Unknown result type (might be due to invalid IL or missing references)
				//IL_0359: Unknown result type (might be due to invalid IL or missing references)
				//IL_035a: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[PlaceShipObjectServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
				}
				else
				{
					if (playerMovedShipObject.TryGetValue(value, out var value2) && value2)
					{
						return;
					}
					((MonoBehaviour)Instance).StartCoroutine(PlaceShipObjectCooldown(value));
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
					if (playerWhoMoved != value)
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to place a ship object while spoofing another player.");
						return;
					}
					if (val.isPlayerDead)
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to place a ship object while dead on the server.");
						return;
					}
					GameObject val2 = NetworkObjectReference.op_Implicit(objectRef);
					if ((Object)(object)val2 == (Object)null)
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to move a ship object that doesn't exist.");
						return;
					}
					PlaceableShipObject componentInChildren = val2.GetComponentInChildren<PlaceableShipObject>();
					if ((Object)(object)componentInChildren == (Object)null)
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to move a ship object using an invalid object. ({((Object)val2).name})");
						return;
					}
					if (configShipObjectRotationCheck.Value && (Mathf.RoundToInt(newRotation.x) != Mathf.RoundToInt(((Component)componentInChildren.mainMesh).transform.eulerAngles.x) || Mathf.RoundToInt(newRotation.z) != Mathf.RoundToInt(((Component)componentInChildren.mainMesh).transform.eulerAngles.z)))
					{
						ManualLogSource log = Log;
						string[] obj = new string[6]
						{
							$"Player #{value} ({val.playerUsername}) ",
							"tried to place a ship object (",
							null,
							null,
							null,
							null
						};
						AutoParentToShip parentObject = componentInChildren.parentObject;
						obj[2] = ((parentObject != null) ? ((Object)parentObject).name : null);
						obj[3] = ") with the wrong rotation. ";
						obj[4] = $"x: ({newRotation.x}) ({((Component)componentInChildren.mainMesh).transform.eulerAngles.x}) ";
						obj[5] = $"z: ({newRotation.z}) ({((Component)componentInChildren.mainMesh).transform.eulerAngles.z})";
						log.LogInfo((object)string.Concat(obj));
						return;
					}
					Bounds bounds = StartOfRound.Instance.shipInnerRoomBounds.bounds;
					if (!((Bounds)(ref bounds)).Contains(newPosition))
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to place a ship object ouside of the ship.");
						return;
					}
					if (senderClientId == 0L)
					{
						instance.PlaceShipObjectServerRpc(newPosition, newRotation, objectRef, playerWhoMoved);
						return;
					}
					ShipTeleporter val3 = default(ShipTeleporter);
					if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.parentObject != (Object)null && ((object)componentInChildren.parentObject).GetType() == typeof(ShipTeleporter) && ((Component)componentInChildren.parentObject).TryGetComponent<ShipTeleporter>(ref val3) && val3.isInverseTeleporter && pressTeleportButtonOnCooldown.Contains(val3))
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) moved inverse teleporter while it is currently teleporting.");
					}
					if (configLogShipObjects.Value)
					{
						ManualLogSource log2 = Log;
						object arg = value;
						string playerUsername = val.playerUsername;
						object arg2;
						if (componentInChildren == null)
						{
							arg2 = null;
						}
						else
						{
							AutoParentToShip parentObject2 = componentInChildren.parentObject;
							arg2 = ((parentObject2 != null) ? ((Object)parentObject2).name : null);
						}
						log2.LogInfo((object)$"Player #{arg} ({playerUsername}) moved ship object. ({arg2})");
					}
					instance.PlaceShipObjectServerRpc(newPosition, newRotation, objectRef, playerWhoMoved);
				}
			}

			public void DespawnEnemyServerRpc(NetworkObjectReference enemyNetworkObject, RoundManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[DespawnEnemyServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				GameObject val = NetworkObjectReference.op_Implicit(enemyNetworkObject);
				if (senderClientId == 0L)
				{
					instance.DespawnEnemyServerRpc(enemyNetworkObject);
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				Log.LogInfo((object)($"Player #{value} ({playerUsername}) attemped to despawn an enemy on the server: " + $"{((val != null) ? ((Object)val).name : null)} {((NetworkObjectReference)(ref enemyNetworkObject)).NetworkObjectId}"));
			}

			public void EndGameServerRpc(int playerClientId, StartOfRound instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[EndGameServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (senderClientId == 0L)
				{
					instance.EndGameServerRpc(playerClientId);
					return;
				}
				if (endGameOnCoolown.TryGetValue(value, out var value2) && value2)
				{
					((MonoBehaviour)Instance).StartCoroutine(EndGameCooldown(value));
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (playerClientId != value)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to end the game while spoofing another player.");
					return;
				}
				if (val.isPlayerDead)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to end the game while dead on the server.");
					return;
				}
				float num = Vector3.Distance(((Component)Object.FindFirstObjectByType<StartMatchLever>()).transform.position, ((Component)val).transform.position);
				if ((float)configLimitShipLeverDistance.Value > 1f && num > (float)configLimitShipLeverDistance.Value)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to end the game while too far away ({num}).");
				}
				else
				{
					instance.EndGameServerRpc(playerClientId);
				}
			}

			public void PlayerLoadedServerRpc(ulong clientId, StartOfRound instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (senderClientId == 0L)
				{
					instance.PlayerLoadedServerRpc(clientId);
					return;
				}
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[PlayerLoadedServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (clientId != senderClientId)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to call PlayerLoadedServerRpc for another client.");
				}
				else if (!instance.fullyLoadedPlayers.Contains(clientId))
				{
					instance.PlayerLoadedServerRpc(clientId);
				}
			}

			public void FinishedGeneratingLevelServerRpc(ulong clientId, RoundManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (senderClientId == 0L)
				{
					instance.FinishedGeneratingLevelServerRpc(clientId);
					return;
				}
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[FinishedGeneratingLevelServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (clientId != senderClientId)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to call FinishedGeneratingLevelServerRpc for another client.");
				}
				else if (!instance.playersFinishedGeneratingFloor.Contains(clientId))
				{
					instance.FinishedGeneratingLevelServerRpc(clientId);
				}
			}

			public void SendNewPlayerValuesServerRpc(ulong newPlayerSteamId, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[SendNewPlayerValuesServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (instance.actualClientId != senderClientId)
				{
					Log.LogInfo((object)($"Player #{value} ({val.playerUsername}) " + $"tried to call SendNewPlayerValuesServerRpc with input value ({newPlayerSteamId}) " + $"on player #{instance.playerClientId} ({instance.playerUsername})."));
					return;
				}
				if (GameNetworkManager.Instance.disableSteam)
				{
					instance.SendNewPlayerValuesServerRpc(newPlayerSteamId);
					return;
				}
				if (!ClientIdToSteamIdMap.TryGetValue(senderClientId, out var value2))
				{
					Log.LogError((object)$"[SendNewPlayerValuesServerRpc] Could not get steamId ({value2}) in steamIdtoClientIdMap");
					return;
				}
				if (((NetworkBehaviour)instance).OwnerClientId != senderClientId)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) SteamId:({value2}) sent SendNewPlayerValuesServerRpc for the wrong player.");
					return;
				}
				if (value2 != newPlayerSteamId)
				{
					Log.LogInfo((object)$"Client sent incorrect steamId. Player's steamId: ({value2}) Sent steamId: ({newPlayerSteamId})");
				}
				instance.SendNewPlayerValuesServerRpc(value2);
			}

			public void DamagePlayerFromOtherClientServerRpc(int damageAmount, Vector3 hitDirection, int playerWhoHit, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0120: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0249: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[DamagePlayerFromOtherClientServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (senderClientId == 0L && playerWhoHit == -1)
				{
					instance.DamagePlayerFromOtherClientServerRpc(damageAmount, hitDirection, playerWhoHit);
				}
				else
				{
					if (damagePlayerFromOtherClientOnCooldown.TryGetValue(value, out var value2) && value2)
					{
						return;
					}
					((MonoBehaviour)instance).StartCoroutine(DamageOtherPlayerCooldown(value));
					if (playerWhoHit != value)
					{
						Log.LogInfo((object)($"Player #{value} ({playerUsername}) tried to spoof ({damageAmount}) damage from player #{playerWhoHit} " + "on (" + instance.playerUsername + ")."));
						return;
					}
					if (val.isPlayerDead)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to damage ({instance.playerUsername}) while they are dead on the server.");
						return;
					}
					if (Vector3.Distance(((Component)val).transform.position, ((Component)instance).transform.position) > 10f)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to damage ({instance.playerUsername}) from too far away.");
						return;
					}
					Shovel obj = Object.FindFirstObjectByType<Shovel>((FindObjectsInactive)1);
					if (obj != null && obj.shovelHitForce == 1 && damageAmount > 20)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to damage ({instance.playerUsername}) for extra damage ({damageAmount})");
						return;
					}
					if (configDisablePvpInShip.Value)
					{
						Bounds bounds = StartOfRound.Instance.shipInnerRoomBounds.bounds;
						if (((Bounds)(ref bounds)).Contains(((Component)instance).transform.position))
						{
							Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to damage ({instance.playerUsername}) inside the ship.");
							return;
						}
					}
					if (configLogPvp.Value)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) damaged ({instance.playerUsername}) for ({damageAmount}) damage.");
					}
					instance.DamagePlayerFromOtherClientServerRpc(damageAmount, hitDirection, playerWhoHit);
				}
			}

			public void ShootGunServerRpc(Vector3 shotgunPosition, Vector3 shotgunForward, ShotgunItem instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//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_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ShootGunServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (senderClientId == 0L && (Object)(object)((GrabbableObject)instance).playerHeldBy == (Object)null)
				{
					instance.ShootGunServerRpc(shotgunPosition, shotgunForward);
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (Vector3.Distance(((Component)instance).transform.position, shotgunPosition) > val.grabDistance + 7f)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to shoot shotgun from too far away from shotgun position.");
				}
				else if (instance.shellsLoaded < 1)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to force shotgun to shoot with no ammo.");
				}
				else
				{
					instance.ShootGunClientRpc(shotgunPosition, shotgunForward);
				}
			}

			public void ReloadGunEffectsServerRpc(bool start, ShotgunItem instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ReloadGunEffectsServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (reloadGunEffectsOnCooldown.TryGetValue(value, out var value2) && value2)
				{
					return;
				}
				((MonoBehaviour)Instance).StartCoroutine(ReloadGunEffectsCooldown(value));
				int num = instance.FindAmmoInInventory();
				if (num == -1)
				{
					return;
				}
				if ((Object)(object)val.ItemSlots[num] == (Object)null)
				{
					Log.LogWarning((object)"Item slot was null while reloading shotgun. Should never be null.");
				}
				if (instance.shellsLoaded < 2)
				{
					if (((object)val.ItemSlots[num]).GetType() == typeof(GunAmmo))
					{
						val.DestroyItemInSlot(num);
					}
					else
					{
						Log.LogWarning((object)$"[ReloadGunEffectsServerRpc] Found item type that wasn't GunAmmo {((object)val.ItemSlots[num]).GetType()}");
					}
					instance.shellsLoaded++;
					instance.ReloadGunEffectsServerRpc(start);
				}
			}

			public void ChangeOwnershipOfPropServerRpc(ulong NewOwner, GrabbableObject instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ChangeOwnershipOfPropServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (senderClientId != 0L)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) called ChangeOwnershipOfPropServerRpc while not the host.");
				}
				else
				{
					instance.ChangeOwnershipOfPropServerRpc(NewOwner);
				}
			}

			public void GrabObjectServerRpc(NetworkObjectReference grabbedObject, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				//IL_029f: Unknown result type (might be due to invalid IL or missing references)
				//IL_02aa: 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_01a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: 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_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0366: Unknown result type (might be due to invalid IL or missing references)
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0337: Unknown result type (might be due to invalid IL or missing references)
				//IL_034a: Unknown result type (might be due to invalid IL or missing references)
				//IL_034c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0351: Unknown result type (might be due to invalid IL or missing references)
				//IL_0353: Unknown result type (might be due to invalid IL or missing references)
				//IL_035b: Unknown result type (might be due to invalid IL or missing references)
				//IL_035d: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0260: Unknown result type (might be due to invalid IL or missing references)
				//IL_026a: Unknown result type (might be due to invalid IL or missing references)
				//IL_027d: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0284: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0290: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[GrabObjectServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (val.isPlayerDead)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to pickup an object while they are dead on the server.");
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
					};
					ClientRpcParams clientRpcParams = val2;
					HostFixesServerSendRpcs.Instance.GrabObjectClientRpc(grabValidated: false, grabbedObject, instance, clientRpcParams);
					return;
				}
				GameObject val3 = NetworkObjectReference.op_Implicit(grabbedObject);
				if ((Object)(object)val3 == (Object)null)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent a network object that does not exist. ({((NetworkObjectReference)(ref grabbedObject)).NetworkObjectId})");
				}
				else if (!configLimitGrabDistance.Value)
				{
					instance.GrabObjectServerRpc(grabbedObject);
				}
				else
				{
					GrabbableObject val4 = default(GrabbableObject);
					if (!val3.TryGetComponent<GrabbableObject>(ref val4))
					{
						return;
					}
					if (val4.isHeld && (Object)(object)val4.playerHeldBy != (Object)null && (Object)(object)val4.playerHeldBy != (Object)(object)val)
					{
						Log.LogInfo((object)($"Player #{value} ({playerUsername}) tried to pickup an object held by someone else " + "(" + val4.playerHeldBy.playerUsername + "). Syncing (" + ((Object)val4).name + ")"));
						ClientRpcParams val2 = default(ClientRpcParams);
						val2.Send = new ClientRpcSendParams
						{
							TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
						};
						ClientRpcParams clientRpcParams2 = val2;
						HostFixesServerSendRpcs.Instance.GrabObjectClientRpc(grabValidated: false, grabbedObject, instance, clientRpcParams2);
						((MonoBehaviour)Instance).StartCoroutine(Call_GrabObjectClientRpc_AfterOneFrame(grabValidated: true, grabbedObject, val4.playerHeldBy, clientRpcParams2));
					}
					else if (configLimitTwoHandedItemPickup.Value && val4.itemProperties.twoHanded && instance.ItemSlots.Any((GrabbableObject item) => (Object)(object)item != (Object)null && item.itemProperties.twoHanded))
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to pickup an extra two-handed object ({((Object)val4).name}");
						ClientRpcParams val2 = default(ClientRpcParams);
						val2.Send = new ClientRpcSendParams
						{
							TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
						};
						ClientRpcParams clientRpcParams3 = val2;
						HostFixesServerSendRpcs.Instance.GrabObjectClientRpc(grabValidated: false, grabbedObject, instance, clientRpcParams3);
					}
					else
					{
						float num = Vector3.Distance(val3.transform.position, ((Component)val).transform.position);
						bool flag = (Object)(object)val3.GetComponent<RagdollGrabbableObject>() == (Object)null;
						if (instance.isInHangarShipRoom && val4.isInShipRoom)
						{
							instance.GrabObjectServerRpc(grabbedObject);
						}
						else if (num > instance.grabDistance + 7f && flag)
						{
							Log.LogInfo((object)($"Player #{value} ({playerUsername}) " + $"Object ({((Object)val3).name}) pickup distance ({num}) is too far away. Could be desync."));
							ClientRpcParams val2 = default(ClientRpcParams);
							val2.Send = new ClientRpcSendParams
							{
								TargetClientIds = new <>z__ReadOnlySingleElementList<ulong>(senderClientId)
							};
							ClientRpcParams clientRpcParams4 = val2;
							HostFixesServerSendRpcs.Instance.GrabObjectClientRpc(grabValidated: false, grabbedObject, instance, clientRpcParams4);
						}
						else
						{
							instance.GrabObjectServerRpc(grabbedObject);
						}
					}
				}
			}

			public void EquipItemServerRpc(GrabbableObject instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[EquipItemServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (!val.isPlayerDead)
				{
					if (!val.ItemSlots.Contains(instance))
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) equipped item is not in ItemSlots. {((Object)instance).name}");
					}
					else
					{
						instance.EquipItemServerRpc();
					}
				}
			}

			public void ThrowObjectServerRpc(NetworkObjectReference grabbedObject, bool droppedInElevator, bool droppedInShipRoom, Vector3 targetFloorPosition, int floorYRot, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0133: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0148: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0107: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0158: Unknown result type (might be due to invalid IL or missing references)
				//IL_0169: Unknown result type (might be due to invalid IL or missing references)
				//IL_0178: Unknown result type (might be due to invalid IL or missing references)
				//IL_017d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_0190: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_0207: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ThrowObjectServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configExperimentalChanges.Value)
				{
					instance.ThrowObjectServerRpc(grabbedObject, droppedInElevator, droppedInShipRoom, targetFloorPosition, floorYRot);
					return;
				}
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				GameObject val = NetworkObjectReference.op_Implicit(grabbedObject);
				if ((Object)(object)val == (Object)null)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to throw an object that doesn't exist. ({grabbedObject.m_NetworkObjectId})");
					return;
				}
				StunGrenadeItem val2 = default(StunGrenadeItem);
				if (val.TryGetComponent<StunGrenadeItem>(ref val2))
				{
					instance.ThrowObjectServerRpc(grabbedObject, droppedInElevator, droppedInShipRoom, targetFloorPosition, floorYRot);
					return;
				}
				GrabbableObject val3 = default(GrabbableObject);
				if (!val.TryGetComponent<GrabbableObject>(ref val3))
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to throw an object that isn't a GrabbleObject. ({((Object)val).name})");
					return;
				}
				Vector3 itemFloorPosition = val3.GetItemFloorPosition(default(Vector3));
				Vector3 val4;
				Vector3 val5;
				if (droppedInElevator)
				{
					val4 = instance.playersManager.elevatorTransform.TransformPoint(targetFloorPosition);
					val5 = instance.playersManager.elevatorTransform.InverseTransformPoint(itemFloorPosition);
				}
				else
				{
					val4 = instance.playersManager.propsContainer.TransformPoint(targetFloorPosition);
					val5 = instance.playersManager.propsContainer.InverseTransformPoint(itemFloorPosition);
				}
				float num = Vector3.Distance(new Vector3(((Component)instance).transform.position.x, ((Component)instance).transform.position.z, 0f), new Vector3(val4.x, val4.z, 0f));
				if (num > instance.grabDistance + 7f)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to throw an object to far away. ({num}) ({((Object)val).name})");
					instance.ThrowObjectServerRpc(grabbedObject, instance.isInElevator, instance.isInHangarShipRoom, val5, floorYRot);
				}
				else
				{
					instance.ThrowObjectServerRpc(grabbedObject, droppedInElevator, droppedInShipRoom, targetFloorPosition, floorYRot);
				}
			}

			public void PlaceObjectServerRpc(NetworkObjectReference grabbedObject, NetworkObjectReference parentObject, Vector3 placePositionOffset, bool matchRotationOfParent, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_004c: 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_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_0181: Unknown result type (might be due to invalid IL or missing references)
				//IL_0191: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: 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_01bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e9: 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_0323: Unknown result type (might be due to invalid IL or missing references)
				//IL_0324: Unknown result type (might be due to invalid IL or missing references)
				//IL_0325: Unknown result type (might be due to invalid IL or missing references)
				//IL_0277: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_028f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0307: Unknown result type (might be due to invalid IL or missing references)
				//IL_0310: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ThrowObjectServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configExperimentalChanges.Value)
				{
					instance.PlaceObjectServerRpc(grabbedObject, parentObject, placePositionOffset, matchRotationOfParent);
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				string playerUsername = val.playerUsername;
				GameObject val2 = NetworkObjectReference.op_Implicit(grabbedObject);
				if ((Object)(object)val2 == (Object)null)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent a grabbed item that doesn't exist ({((NetworkObjectReference)(ref grabbedObject)).NetworkObjectId})");
					return;
				}
				GameObject val3 = NetworkObjectReference.op_Implicit(parentObject);
				if ((Object)(object)val3 == (Object)null)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent a parent object that doesn't exist ({((NetworkObjectReference)(ref parentObject)).NetworkObjectId})");
					return;
				}
				GrabbableObject val4 = default(GrabbableObject);
				if (!val2.TryGetComponent<GrabbableObject>(ref val4))
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to place an object that isn't a grabbable object ({((Object)val2).name})");
					return;
				}
				if (val4.isHeld && (Object)(object)val4.playerHeldBy != (Object)null && (Object)(object)val4.playerHeldBy != (Object)(object)val)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to place an object held by someone else. ({((Object)val4).name}) ({val4.playerHeldBy})");
					return;
				}
				float num = Vector3.Distance(((Component)instance).transform.position, val3.transform.position);
				Vector3 itemFloorPosition = val4.GetItemFloorPosition(default(Vector3));
				Vector3 val5 = ((!instance.isInElevator) ? instance.playersManager.propsContainer.InverseTransformPoint(itemFloorPosition) : instance.playersManager.elevatorTransform.InverseTransformPoint(itemFloorPosition));
				DepositItemsDesk val6 = default(DepositItemsDesk);
				if (num > instance.grabDistance + 7f)
				{
					if (itemFloorPosition == ((Component)instance).transform.position)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to place an object too far away and it didn't fall. {((Object)val4).name} {itemFloorPosition}");
					}
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to place an object too far away. ({(int)num}) ({((Object)val4).name})");
					instance.ThrowObjectServerRpc(grabbedObject, instance.isInElevator, instance.isInHangarShipRoom, val5, (int)((Component)instance).transform.localEulerAngles.y);
				}
				else if ((Object)(object)val3.transform.parent != (Object)null && ((Component)val3.transform.parent).TryGetComponent<DepositItemsDesk>(ref val6) && ((Component)val6.deskObjectsContainer).GetComponentsInChildren<GrabbableObject>().Length > 12)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to place extra items on the company desk.");
					instance.ThrowObjectServerRpc(grabbedObject, instance.isInElevator, instance.isInHangarShipRoom, val5, (int)((Component)instance).transform.localEulerAngles.y);
				}
				else
				{
					instance.PlaceObjectServerRpc(grabbedObject, parentObject, placePositionOffset, matchRotationOfParent);
				}
			}

			public void AddObjectToDeskServerRpc(NetworkObjectReference grabbableObjectNetObject, DepositItemsDesk instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: 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_0048: 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_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ThrowObjectServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configExperimentalChanges.Value)
				{
					instance.AddObjectToDeskServerRpc(grabbableObjectNetObject);
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				string playerUsername = val.playerUsername;
				GameObject val2 = NetworkObjectReference.op_Implicit(grabbableObjectNetObject);
				if ((Object)(object)val2 == (Object)null)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent a grabbable object that doesn't exist. ({((NetworkObjectReference)(ref grabbableObjectNetObject)).NetworkObjectId})");
				}
				else if (!(Vector3.Distance(((Component)val).transform.position, ((Component)instance.deskObjectsContainer).transform.position) > val.grabDistance + 7f))
				{
					GrabbableObject val3 = default(GrabbableObject);
					if (((Component)instance.deskObjectsContainer).GetComponentsInChildren<GrabbableObject>().Length > 12)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to add extra items to the company desk.");
					}
					else if (!val2.TryGetComponent<GrabbableObject>(ref val3))
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to add an object to the desk that isn't a grabbable object ({((Object)val2).name})");
					}
					else if (val3.isHeld && (Object)(object)val3.playerHeldBy != (Object)(object)val)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to add an object to the desk held by someone else. ({((Object)val3).name})");
					}
					else
					{
						instance.AddObjectToDeskServerRpc(grabbableObjectNetObject);
					}
				}
			}

			public void SetTimesHeardNoiseServerRpc(float valueChange, DepositItemsDesk instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (serverRpcParams.Receive.SenderClientId == 0L)
				{
					instance.SetTimesHeardNoiseServerRpc(valueChange * (float)(StartOfRound.Instance.connectedPlayersAmount + 1));
				}
			}

			public void SetPatienceServerRpc(float valueChange, DepositItemsDesk instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var _))
				{
					Log.LogError((object)$"[SetPatienceServerRpc] Failed to get the playerId from clientId: {senderClientId}");
				}
				else if (senderClientId == 0L)
				{
					instance.SetPatienceServerRpc(valueChange * (float)(StartOfRound.Instance.connectedPlayersAmount + 1));
				}
			}

			public void SetShipLightsServerRpc(bool setLightsOn, ShipLights instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[SetShipLightsServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
				}
				else if (senderClientId == 0L)
				{
					StartOfRound.Instance.shipRoomLights.SetShipLightsServerRpc(setLightsOn);
				}
				else
				{
					if (shipLightsOnCooldown)
					{
						return;
					}
					((MonoBehaviour)Instance).StartCoroutine(ShipLightsCooldown());
					string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
					if (val.isPlayerDead)
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to toggle ship lights while they are dead on the server.");
						return;
					}
					float num = Vector3.Distance(((Component)instance).transform.position, ((Component)val).transform.position);
					if (num > 20f && !val.ItemSlots.Any((GrabbableObject item) => (Object)(object)item != (Object)null && new Func<RemoteProp>(((Component)item).GetComponent<RemoteProp>) != null))
					{
						Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to toggle ship lights without a remote from too faw away. ({num})");
					}
					else
					{
						instance.SetShipLightsServerRpc(setLightsOn);
					}
				}
			}

			public void UseSignalTranslatorServerRpc(string signalMessage, HUDManager instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[UseSignalTranslatorServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				string playerUsername = val.playerUsername;
				if (StartOfRound.Instance.allPlayerScripts[value].isPlayerDead)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) tried to send a Signal Translator message while they are dead on the server." + " Message: (" + signalMessage + ")"));
					return;
				}
				if (configLogSignalTranslatorMessages.Value)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) sent signal translator message: ({signalMessage})");
				}
				if (Vector3.Distance(((Component)Object.FindObjectOfType<Terminal>()).transform.position, ((Component)val).transform.position) > 20f)
				{
					Log.LogInfo((object)$"Player #{value} ({playerUsername}) tried to send signal translator message to far away from terminal.");
				}
				else
				{
					instance.UseSignalTranslatorServerRpc(signalMessage);
				}
			}

			public void TeleportPlayerServerRpc(int playerObj, EntranceTeleport instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[TeleportPlayerServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (senderClientId == 0L)
				{
					instance.TeleportPlayerServerRpc(playerObj);
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (playerObj != value)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to teleport another player using an entrance teleport)");
					return;
				}
				float num = Vector3.Distance(instance.entrancePoint.position, ((Component)val).transform.position);
				if (num > 10f)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) too far away from entrance to teleport ({num})");
					return;
				}
				Transform exitPoint = instance.exitPoint;
				if ((Object)(object)exitPoint == (Object)null)
				{
					instance.FindExitPoint();
					exitPoint = instance.exitPoint;
				}
				playerPositions[(ulong)value] = exitPoint.position;
				instance.TeleportPlayerServerRpc(playerObj);
			}

			public void PressTeleportButtonServerRpc(ShipTeleporter instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[PressTeleportButtonServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
				}
				else
				{
					if (pressTeleportButtonOnCooldown.Contains(instance))
					{
						return;
					}
					((MonoBehaviour)Instance).StartCoroutine(PressTeleportButtonCooldown(instance));
					if (senderClientId == 0L)
					{
						instance.PressTeleportButtonServerRpc();
						return;
					}
					PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
					if (val.isPlayerDead)
					{
						Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to press teleporter button while they are dead on the server.");
						return;
					}
					float num = Vector3.Distance(((Component)val).transform.position, ((Component)instance.buttonTrigger).transform.position);
					if ((float)configLimitTeleporterButtonDistance.Value > 1f && num > (float)configLimitTeleporterButtonDistance.Value)
					{
						Log.LogInfo((object)($"Player #{value} ({val.playerUsername}) tried to press teleporter button from too far away " + $"({num})"));
					}
					else
					{
						instance.PressTeleportButtonServerRpc();
					}
				}
			}

			public void TeleportPlayerOutServerRpc(int playerObj, Vector3 teleportPos, ShipTeleporter instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: 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)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[TeleportPlayerOutServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (playerObj != value)
				{
					Log.LogInfo((object)$"[TeleportPlayerOutServerRpc] playerObj ({playerObj}) != senderPlayerId ({value})");
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				playerPositions[val.playerClientId] = ((Component)val).transform.localPosition;
				instance.TeleportPlayerOutServerRpc(playerObj, teleportPos);
			}

			public void UpdatePlayerPositionServerRpc(Vector3 newPos, bool inElevator, bool inShipRoom, bool exhausted, bool isPlayerGrounded, PlayerControllerB instance, ServerRpcParams serverRpcParams)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: 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_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Unknown result type (might be due to invalid IL or missing references)
				//IL_0106: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_017f: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = serverRpcParams.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[UpdatePlayerPositionServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (instance.isPlayerDead)
				{
					allowedMovement[instance.playerClientId] = false;
					return;
				}
				Vector3 val = (inElevator ? ((Component)instance).transform.localPosition : ((Component)instance).transform.position);
				if (!onShip.TryGetValue(instance.playerClientId, out var value2) || value2 != inElevator)
				{
					playerPositions[instance.playerClientId] = val;
					positionCacheUpdateTime[instance.playerClientId] = Time.time;
					onShip[instance.playerClientId] = inElevator;
				}
				PlayerControllerB val2 = StartOfRound.Instance.allPlayerScripts[value];
				if (configExperimentalPositionCheck.Value && !StartOfRound.Instance.suckingPlayersOutOfShip && !StartOfRound.Instance.inShipPhase)
				{
					Vector3 val3 = newPos - val;
					if (!(Vector3.Dot(((Vector3)(ref val3)).normalized, Vector3.down) > 0.3f))
					{
						if (Vector3.Distance(newPos, playerPositions[instance.playerClientId]) > 150f)
						{
							InfoPanel.Instance.Log($"Player #{value} ({val2.playerUsername}) UpdatePlayerPositionServerRpc {Vector3.Distance(newPos, playerPositions[instance.playerClientId])}");
							allowedMovement[instance.playerClientId] = false;
						}
						else
						{
							allowedMovement[instance.playerClientId] = true;
							instance.UpdatePlayerPositionServerRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
						}
						return;
					}
				}
				instance.UpdatePlayerPositionServerRpc(newPos, inElevator, inShipRoom, exhausted, isPlayerGrounded);
				allowedMovement[instance.playerClientId] = true;
			}

			public void UpdatePlayerRotationServerRpc(short newRot, short newYRot, PlayerControllerB instance, ServerRpcParams _)
			{
				if (!allowedMovement.ContainsKey(instance.playerClientId) || allowedMovement[instance.playerClientId])
				{
					instance.UpdatePlayerRotationSer