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("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[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.Components")]
[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.28.0")]
[assembly: AssemblyInformationalVersion("1.0.28+f06389a2b93adff3a28cde2ee72bfa2ecca653d2")]
[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.28.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), "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_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)NetworkManager.Singleton != (Object)null && NetworkManager.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
		{
			[HarmonyPriority(800)]
			public static void Prefix(GameNetworkManager __instance, ref ConnectionApprovalRequest request)
			{
				if (!__instance.disableSteam)
				{
					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;
					}
				}
			}

			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))
				{
					if ((Object)(object)StartOfRound.Instance != (Object)null && StartOfRound.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.28")]
	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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b5: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: 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_0124: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: 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_023e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0240: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0306: 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)
				//IL_0323: 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_032a: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: 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)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: 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_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: 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_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_0131: 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_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_02cd: 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_02d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f4: 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)
				//IL_0364: Unknown result type (might be due to invalid IL or missing references)
				//IL_0377: 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_037e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0380: Unknown result type (might be due to invalid IL or missing references)
				//IL_039e: Unknown result type (might be due to invalid IL or missing references)
				//IL_03f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_040e: 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_0415: Unknown result type (might be due to invalid IL or missing references)
				//IL_0417: Unknown result type (might be due to invalid IL or missing references)
				//IL_0435: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (string.IsNullOrWhiteSpace(chatMessage))
				{
					return;
				}
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 (senderClientId == 0L)
				{
					instance.AddTextMessageServerRpc(chatMessage);
				}
				else if (chatMessage.Equals($"[playerNum{value}] started the ship."))
				{
					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 (!chatMessage.Equals(playerUsername + " joined the ship.") && !chatMessage.Equals(value2 + " joined the ship.") && !chatMessage.Equals(value2 + "... joined the ship.") && !chatMessage.Equals(playerUsername + " was left behind."))
					{
						Log.LogInfo((object)$"Player #{value} ({value2}) tried to send message as the server: ({chatMessage})");
					}
					else
					{
						instance.AddTextMessageServerRpc(chatMessage);
					}
				}
			}

			public void SetShipLeaveEarlyServerRpc(TimeOfDay instance, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_024f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0254: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Unknown result type (might be due to invalid IL or missing references)
				//IL_01db: 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_020e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: 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_017d: 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_0287: 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_0383: Unknown result type (might be due to invalid IL or missing references)
				//IL_0384: Unknown result type (might be due to invalid IL or missing references)
				//IL_0385: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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)))
					{
						Log.LogInfo((object)($"Player #{value} ({val.playerUsername}) " + "tried to place a ship object (" + ((Object)componentInChildren.parentObject).name + ") with the wrong rotation. " + $"x: ({newRotation.x}) ({((Component)componentInChildren.mainMesh).transform.eulerAngles.x}) " + $"z: ({newRotation.z}) ({((Component)componentInChildren.mainMesh).transform.eulerAngles.z})"));
						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)
					{
						if ((Object)(object)componentInChildren != (Object)null && (Object)(object)componentInChildren.parentObject != (Object)null)
						{
							Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) moved ship object. ({((Object)componentInChildren.parentObject).name})");
						}
						else
						{
							Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) moved ship object.");
						}
					}
					instance.PlaceShipObjectServerRpc(newPosition, newRotation, objectRef, playerWhoMoved);
				}
			}

			public void DespawnEnemyServerRpc(NetworkObjectReference enemyNetworkObject, RoundManager instance, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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);
				string playerUsername = StartOfRound.Instance.allPlayerScripts[value].playerUsername;
				if (senderClientId != 0L)
				{
					Log.LogInfo((object)($"Player #{value} ({playerUsername}) attemped to despawn an enemy on the server: " + string.Format("{0} {1}", ((Object)(object)val != (Object)null) ? ((Object)val).name : "null", ((NetworkObjectReference)(ref enemyNetworkObject)).NetworkObjectId)));
				}
				else
				{
					instance.DespawnEnemyServerRpc(enemyNetworkObject);
				}
			}

			public void EndGameServerRpc(int playerClientId, StartOfRound instance, __RpcParams RpcParams)
			{
				//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_0006: 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_00df: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0119: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_025c: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 val2 = Object.FindFirstObjectByType<Shovel>((FindObjectsInactive)1);
					bool flag = true;
					if ((Object)(object)val2 != (Object)null)
					{
						flag = val2.shovelHitForce == 1;
					}
					if (flag && 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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_00db: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 && !instance.localClientSendingShootGunRPC)
				{
					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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[ReloadGunEffectsServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configPreventInfiniteShotgunAmmo.Value || start)
				{
					instance.ReloadGunEffectsServerRpc(start);
					return;
				}
				_ = StartOfRound.Instance.allPlayerScripts[value];
				if (reloadGunEffectsOnCooldown.TryGetValue(value, out var value2) && value2)
				{
					instance.gunAnimator.SetBool("Reloading", false);
					instance.isReloading = false;
					return;
				}
				((MonoBehaviour)Instance).StartCoroutine(ReloadGunEffectsCooldown(value));
				if (instance.shellsLoaded >= 2)
				{
					instance.gunAnimator.SetBool("Reloading", false);
					instance.isReloading = false;
				}
				else if (!ammoHasBeenDeletedOnReload[value])
				{
					instance.gunAnimator.SetBool("Reloading", false);
					instance.isReloading = false;
				}
				else
				{
					ammoHasBeenDeletedOnReload[value] = false;
					instance.ReloadGunEffectsServerRpc(start);
				}
			}

			public void DestroyItemInSlotServerRpc(int itemSlot, PlayerControllerB instance, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.Receive.SenderClientId;
				if (!StartOfRound.Instance.ClientPlayerList.TryGetValue(senderClientId, out var value))
				{
					Log.LogError((object)$"[DestroyItemInSlotServerRpc] Failed to get the playerId from senderClientId: {senderClientId}");
					return;
				}
				if (!configPreventInfiniteShotgunAmmo.Value)
				{
					instance.DestroyItemInSlotServerRpc(itemSlot);
					return;
				}
				PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[value];
				if (itemSlot < 0 && itemSlot > val.ItemSlots.Count() - 1)
				{
					Log.LogInfo((object)$"Player #{value} ({val.playerUsername}) tried to destory item in slot ({itemSlot}) while the last slot is ({val.ItemSlots.Count() - 1}");
				}
				else if (((object)val.ItemSlots[itemSlot]).GetType() != typeof(GunAmmo))
				{
					if (senderClientId == 0L)
					{
						Log.LogWarning((object)$"[DestroyItemInSlotServerRpc] New item type being deleted? ({((object)val.ItemSlots[itemSlot]).GetType()})");
					}
				}
				else
				{
					ammoHasBeenDeletedOnReload[value] = true;
					instance.DestroyItemInSlotServerRpc(itemSlot);
				}
			}

			public void ChangeOwnershipOfPropServerRpc(ulong NewOwner, GrabbableObject instance, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: 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_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0103: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_02af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: 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_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_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_036b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0332: Unknown result type (might be due to invalid IL or missing references)
				//IL_033c: Unknown result type (might be due to invalid IL or missing references)
				//IL_034f: 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_0356: 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_0360: Unknown result type (might be due to invalid IL or missing references)
				//IL_0362: Unknown result type (might be due to invalid IL or missing references)
				//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0265: Unknown result type (might be due to invalid IL or missing references)
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0282: 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_0289: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0293: Unknown result type (might be due to invalid IL or missing references)
				//IL_0295: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: 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_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: 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_00fb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: 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_013f: Unknown result type (might be due to invalid IL or missing references)
				//IL_014d: 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_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_010c: 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_0113: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: 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_0128: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: 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_0182: Unknown result type (might be due to invalid IL or missing references)
				//IL_0189: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_0209: Unknown result type (might be due to invalid IL or missing references)
				//IL_020c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: 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_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_017a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: 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_01a3: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: 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_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_032b: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: 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_027c: Unknown result type (might be due to invalid IL or missing references)
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0294: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0300: Unknown result type (might be due to invalid IL or missing references)
				//IL_030f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0318: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 >= 150)
				{
					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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0068: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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 >= 150)
					{
						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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				if (RpcParams.Server.Receive.SenderClientId == 0L)
				{
					instance.SetTimesHeardNoiseServerRpc(valueChange * (float)(StartOfRound.Instance.connectedPlayersAmount + 1));
				}
			}

			public void SetPatienceServerRpc(float valueChange, DepositItemsDesk instance, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0006: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				ulong senderClientId = RpcParams.Server.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, __RpcParams RpcParams)
			{
				//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_0007: 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_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: 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_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0100: Unknown result type (might be due to invalid I