using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using AdditionalNetworking.Components;
using AdditionalNetworking.Dependency;
using AdditionalNetworking.NetcodePatcher;
using AsyncLoggers.DBAPI;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LobbyCompatibility.Enums;
using LobbyCompatibility.Features;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: AssemblyCompany("AdditionalNetworking")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.0.9.0")]
[assembly: AssemblyInformationalVersion("0.0.9+6309141e9ccc743c894159808c655b47636ba7c8")]
[assembly: AssemblyProduct("Additional Networking")]
[assembly: AssemblyTitle("AdditionalNetworking")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.9.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 AdditionalNetworking
{
	[BepInPlugin("mattymatty.AdditionalNetworking", "AdditionalNetworking", "0.0.9")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class AdditionalNetworking : BaseUnityPlugin
	{
		internal static class PluginConfig
		{
			internal static void Init(BaseUnityPlugin plugin)
			{
				ConfigFile config = plugin.Config;
				PropertyInfo property = ((object)config).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
				Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(config, null);
				dictionary.Clear();
				config.Save();
			}
		}

		public const string GUID = "mattymatty.AdditionalNetworking";

		public const string NAME = "AdditionalNetworking";

		public const string VERSION = "0.0.9";

		internal static ManualLogSource Log;

		internal const uint NetworkObjectIdHash = 28111997u;

		internal static GameObject NetcodeContainer { get; private set; }

		internal static GameObject NetcodePrefab { get; private set; }

		private void Awake()
		{
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			try
			{
				if (LobbyCompatibilityChecker.Enabled)
				{
					LobbyCompatibilityChecker.Init();
				}
				if (AsyncLoggerProxy.Enabled)
				{
					AsyncLoggerProxy.WriteEvent("AdditionalNetworking", "Awake", "Initializing");
				}
				Log.LogInfo((object)"Initializing Configs");
				PluginConfig.Init((BaseUnityPlugin)(object)this);
				Log.LogInfo((object)"Initializing Netcode");
				Type[] types = Assembly.GetExecutingAssembly().GetTypes();
				Type[] array = types;
				foreach (Type type in array)
				{
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
					MethodInfo[] array2 = methods;
					foreach (MethodInfo methodInfo in array2)
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
						if (customAttributes.Length != 0)
						{
							methodInfo.Invoke(null, null);
						}
					}
				}
				NetcodeContainer = new GameObject("AdditionalNetworkingContainer");
				GameObject netcodeContainer = NetcodeContainer;
				((Object)netcodeContainer).hideFlags = (HideFlags)(((Object)netcodeContainer).hideFlags | 0x3D);
				Object.DontDestroyOnLoad((Object)(object)NetcodeContainer);
				NetcodeContainer.SetActive(false);
				NetcodePrefab = new GameObject("AdditionalNetworkingPrefab");
				NetcodePrefab.transform.parent = NetcodeContainer.transform;
				NetworkObject val = NetcodePrefab.AddComponent<NetworkObject>();
				val.AutoObjectParentSync = false;
				val.GlobalObjectIdHash = 28111997u;
				NetcodePrefab.AddComponent<PlayerNetworking>();
				NetcodePrefab.AddComponent<ShotgunNetworking>();
				NetcodePrefab.AddComponent<BoomboxNetworking>();
				Log.LogInfo((object)"Patching Methods");
				Harmony val2 = new Harmony("mattymatty.AdditionalNetworking");
				val2.PatchAll();
				Log.LogInfo((object)"AdditionalNetworking v0.0.9 Loaded!");
				if (AsyncLoggerProxy.Enabled)
				{
					AsyncLoggerProxy.WriteEvent("AdditionalNetworking", "Awake", "Finished Initializing");
				}
			}
			catch (Exception ex)
			{
				Log.LogError((object)("Exception while initializing: \n" + ex));
			}
		}
	}
}
namespace AdditionalNetworking.Patches
{
	[HarmonyPatch]
	internal class BoomboxItemPatch
	{
		internal static readonly Dictionary<BoomboxItem, bool> DirtyStatus = new Dictionary<BoomboxItem, bool>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(BoomboxItem), "Start")]
		private static void OnStart(BoomboxItem __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)BoomboxNetworking.Instance == (Object)null) && BoomboxNetworking.Instance.Enabled && !((NetworkBehaviour)__instance).IsServer)
			{
				BoomboxNetworking.Instance.RequestSyncServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject));
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(BoomboxItem), "StartMusic")]
		private static void OnMusicChange(BoomboxItem __instance)
		{
			if (!((Object)(object)BoomboxNetworking.Instance == (Object)null) && BoomboxNetworking.Instance.Enabled && ((NetworkBehaviour)__instance).IsOwner)
			{
				DirtyStatus[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(GrabbableObject), "LateUpdate")]
		private static void OnLateUpdate(GrabbableObject __instance)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			BoomboxItem val = (BoomboxItem)(object)((__instance is BoomboxItem) ? __instance : null);
			if (!((Object)(object)val == (Object)null) && !((Object)(object)BoomboxNetworking.Instance == (Object)null) && BoomboxNetworking.Instance.Enabled && DirtyStatus.TryGetValue(val, out var value) && value)
			{
				DirtyStatus[val] = false;
				if (((NetworkBehaviour)__instance).IsOwner)
				{
					int track = Array.IndexOf(val.musicAudios, val.boomboxAudio.clip);
					bool isPlayingMusic = val.isPlayingMusic;
					BoomboxNetworking.Instance.SyncStateServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), isPlayingMusic, track);
				}
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(NetworkBehaviour), "OnDestroy")]
		private static void OnDestroy(NetworkBehaviour __instance)
		{
			BoomboxItem val = (BoomboxItem)(object)((__instance is BoomboxItem) ? __instance : null);
			if (!((Object)(object)val == (Object)null))
			{
				DirtyStatus.Remove(val);
			}
		}
	}
	[HarmonyPatch]
	internal class DebugPatches
	{
	}
	[HarmonyPatch]
	internal class NetworkManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(NetworkManager), "SetSingleton")]
		private static void AfterSingleton(NetworkManager __instance)
		{
			__instance.AddNetworkPrefab(AdditionalNetworking.NetcodePrefab);
			AdditionalNetworking.Log.LogInfo((object)"Added Prefab!");
		}
	}
	[HarmonyPatch]
	internal class NetworkSceneManagerPatch
	{
	}
	[HarmonyPatch]
	internal class NutcrackerEnemyAiPatch
	{
		[HarmonyFinalizer]
		[HarmonyPatch(typeof(NutcrackerEnemyAI), "ReloadGunClientRpc")]
		private static void OnReload(NutcrackerEnemyAI __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
			if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening && (int)((NetworkBehaviour)__instance).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && ((NetworkBehaviour)__instance).IsOwner && ((Object)(object)ShotgunNetworking.Instance == (Object)null || !ShotgunNetworking.Instance.Enabled))
			{
				ShotgunNetworking.Instance.SyncAmmoServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance.gun).NetworkObject), __instance.gun.shellsLoaded);
			}
		}
	}
	[HarmonyPatch]
	internal class PlayerControllerBPatch
	{
		internal static readonly Dictionary<PlayerControllerB, bool> DirtySlots = new Dictionary<PlayerControllerB, bool>();

		internal static readonly Dictionary<PlayerControllerB, bool> DirtyInventory = new Dictionary<PlayerControllerB, bool>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayerControllerB), "Start")]
		private static void OnStart(PlayerControllerB __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)PlayerNetworking.Instance == (Object)null) && PlayerNetworking.Instance.Enabled && !((NetworkBehaviour)__instance).IsServer)
			{
				PlayerNetworking.Instance.RequestSyncUsernameServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject));
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "SwitchToItemSlot")]
		private static void OnSlotChange(PlayerControllerB __instance, int slot)
		{
			DirtySlots[__instance] = true;
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "GrabObjectClientRpc")]
		private static void OnItemGrabbed(PlayerControllerB __instance, bool grabValidated)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)__instance).NetworkManager;
			if (!((Object)(object)networkManager == (Object)null) && networkManager.IsListening && (int)((NetworkBehaviour)__instance).__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !((Object)(object)PlayerNetworking.Instance == (Object)null) && PlayerNetworking.Instance.Enabled && grabValidated)
			{
				DirtyInventory[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "DiscardHeldObject")]
		private static void OnDiscardItem(PlayerControllerB __instance)
		{
			if (!((Object)(object)PlayerNetworking.Instance == (Object)null) && PlayerNetworking.Instance.Enabled)
			{
				DirtyInventory[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "DropAllHeldItems")]
		private static void OnDropItem(PlayerControllerB __instance)
		{
			if (!((Object)(object)PlayerNetworking.Instance == (Object)null) && PlayerNetworking.Instance.Enabled)
			{
				DirtyInventory[__instance] = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayerControllerB), "ConnectClientToPlayerObject")]
		private static void OnPlayerConnected(PlayerControllerB __instance)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)PlayerNetworking.Instance == (Object)null) && PlayerNetworking.Instance.Enabled && !((NetworkBehaviour)__instance).IsServer && ((NetworkBehaviour)__instance).IsOwner)
			{
				PlayerNetworking.Instance.SyncUsernameServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), __instance.playerUsername);
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "LateUpdate")]
		private static void OnLateUpdate(PlayerControllerB __instance)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)PlayerNetworking.Instance == (Object)null || !PlayerNetworking.Instance.Enabled)
			{
				return;
			}
			if (DirtySlots.TryGetValue(__instance, out var value) && value)
			{
				DirtySlots[__instance] = false;
				if (((NetworkBehaviour)__instance).IsOwner)
				{
					PlayerNetworking.Instance.SyncSelectedSlotServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), __instance.currentItemSlot);
				}
			}
			if (!(DirtyInventory.TryGetValue(__instance, out var value2) && value2))
			{
				return;
			}
			DirtyInventory[__instance] = false;
			if (!((NetworkBehaviour)__instance).IsOwner)
			{
				return;
			}
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			for (int i = 0; i < __instance.ItemSlots.Length; i++)
			{
				GrabbableObject val = __instance.ItemSlots[i];
				if ((Object)(object)val != (Object)null && (Object)(object)((NetworkBehaviour)val).NetworkObject != (Object)null)
				{
					list.Add(NetworkObjectReference.op_Implicit(((NetworkBehaviour)val).NetworkObject));
					list2.Add(i);
				}
			}
			PlayerNetworking.Instance.SyncInventoryServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), list.ToArray(), list2.ToArray());
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(PlayerControllerB), "OnDestroy")]
		private static void OnDestroy(PlayerControllerB __instance)
		{
			DirtyInventory.Remove(__instance);
			DirtySlots.Remove(__instance);
		}
	}
	[HarmonyPatch]
	internal class ShotgunItemPatch
	{
		internal static readonly Dictionary<ShotgunItem, bool> DirtyAmmo = new Dictionary<ShotgunItem, bool>();

		internal static readonly Dictionary<ShotgunItem, bool> DirtySafety = new Dictionary<ShotgunItem, bool>();

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ShotgunItem), "Start")]
		private static void OnStart(ShotgunItem __instance)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)ShotgunNetworking.Instance == (Object)null) && ShotgunNetworking.Instance.Enabled && !((NetworkBehaviour)__instance).IsServer)
			{
				ShotgunNetworking.Instance.RequestSyncServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject));
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(ShotgunItem), "ReloadGunEffectsServerRpc")]
		private static void OnAmmoReload(ShotgunItem __instance, bool start)
		{
			if (!((Object)(object)ShotgunNetworking.Instance == (Object)null) && ShotgunNetworking.Instance.Enabled && !start && ((NetworkBehaviour)__instance).IsOwner)
			{
				DirtyAmmo[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(ShotgunItem), "ShootGun")]
		private static void OnShot(ShotgunItem __instance)
		{
			if (!((Object)(object)ShotgunNetworking.Instance == (Object)null) && ShotgunNetworking.Instance.Enabled && ((NetworkBehaviour)__instance).IsOwner)
			{
				DirtyAmmo[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(ShotgunItem), "ItemInteractLeftRight")]
		private static void OnSafetyToggle(ShotgunItem __instance, bool right)
		{
			if (!((Object)(object)ShotgunNetworking.Instance == (Object)null) && ShotgunNetworking.Instance.Enabled && ((NetworkBehaviour)__instance).IsOwner)
			{
				DirtySafety[__instance] = true;
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(GrabbableObject), "LateUpdate")]
		private static void OnLateUpdate(GrabbableObject __instance)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			ShotgunItem val = (ShotgunItem)(object)((__instance is ShotgunItem) ? __instance : null);
			if ((Object)(object)val == (Object)null || (Object)(object)ShotgunNetworking.Instance == (Object)null || !ShotgunNetworking.Instance.Enabled)
			{
				return;
			}
			if (DirtyAmmo.TryGetValue(val, out var value) && value)
			{
				DirtyAmmo[val] = false;
				if (((NetworkBehaviour)__instance).IsOwner)
				{
					ShotgunNetworking.Instance.SyncAmmoServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), val.shellsLoaded);
				}
			}
			if (DirtySafety.TryGetValue(val, out var value2) && value2)
			{
				DirtySafety[val] = false;
				if (((NetworkBehaviour)__instance).IsOwner)
				{
					ShotgunNetworking.Instance.SyncSafetyServerRpc(NetworkObjectReference.op_Implicit(((NetworkBehaviour)__instance).NetworkObject), val.safetyOn);
				}
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(NetworkBehaviour), "OnDestroy")]
		private static void OnDestroy(NetworkBehaviour __instance)
		{
			ShotgunItem val = (ShotgunItem)(object)((__instance is ShotgunItem) ? __instance : null);
			if (!((Object)(object)val == (Object)null))
			{
				DirtySafety.Remove(val);
				DirtyAmmo.Remove(val);
			}
		}
	}
	[HarmonyPatch]
	internal class StartOfRoundPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(StartOfRound), "Start")]
		private static void OnStart(StartOfRound __instance)
		{
			if (((NetworkBehaviour)__instance).IsServer)
			{
				AdditionalNetworking.Log.LogDebug((object)"Here!");
				GameObject val = Object.Instantiate<GameObject>(AdditionalNetworking.NetcodePrefab);
				((Object)val).name = "AdditionalNetworking";
				NetworkObject component = val.GetComponent<NetworkObject>();
				component.Spawn(false);
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(StartOfRound), "OnClientDisconnect")]
		private static void OnClientDisconnect(ulong clientId)
		{
			if ((Object)(object)PlayerNetworking.Instance != (Object)null)
			{
				PlayerNetworking.Instance.ValidClientIDs.Remove(clientId);
			}
			if ((Object)(object)ShotgunNetworking.Instance != (Object)null)
			{
				ShotgunNetworking.Instance.ValidClientIDs.Remove(clientId);
			}
		}

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(StartOfRound), "OnLocalDisconnect")]
		private static void OnLocalDisconnect()
		{
			PlayerControllerBPatch.DirtyInventory.Clear();
			PlayerControllerBPatch.DirtySlots.Clear();
			ShotgunItemPatch.DirtyAmmo.Clear();
			ShotgunItemPatch.DirtySafety.Clear();
		}
	}
}
namespace AdditionalNetworking.Dependency
{
	public static class AsyncLoggerProxy
	{
		private static bool? _enabled;

		public static bool Enabled
		{
			get
			{
				if (_enabled.HasValue)
				{
					return _enabled.Value;
				}
				try
				{
					_enabled = isDbEnabled();
				}
				catch (Exception)
				{
					_enabled = false;
					return false;
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void WriteEvent(string source, string tag, string data, DateTime? timestamp = null)
		{
			SqliteLogger.WriteEvent(source, tag, data, timestamp);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void WriteData(string source, string tag, string data, DateTime? timestamp = null)
		{
			SqliteLogger.WriteData(source, tag, data, timestamp);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool isDbEnabled()
		{
			return SqliteLogger.Enabled;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static int getExecutionID()
		{
			return SqliteLogger.ExecutionId;
		}
	}
	public static class LobbyCompatibilityChecker
	{
		private static bool? _enabled;

		public static bool Enabled
		{
			get
			{
				bool valueOrDefault = _enabled.GetValueOrDefault();
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("BMX.LobbyCompatibility");
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			PluginHelper.RegisterPlugin("mattymatty.AdditionalNetworking", Version.Parse("0.0.9"), (CompatibilityLevel)2, (VersionStrictness)2);
		}
	}
}
namespace AdditionalNetworking.Components
{
	public class BoomboxNetworking : NetworkBehaviour
	{
		internal HashSet<ulong> ValidClientIDs = new HashSet<ulong>();

		public static BoomboxNetworking Instance { get; private set; }

		public bool Enabled { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			OnConnectServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		public void OnConnectServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(397310893u, serverRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 397310893u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { serverRpcParams.Receive.SenderClientId }
					};
					ClientRpcParams clientRpcParams = val2;
					AdditionalNetworking.Log.LogInfo((object)string.Format("{0} registered on {1}", serverRpcParams.Receive.SenderClientId, "BoomboxNetworking"));
					ValidClientIDs.Add(serverRpcParams.Receive.SenderClientId);
					AckConnectClientRpc(clientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void AckConnectClientRpc(ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1758458060u, clientRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 1758458060u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Enabled = true;
					AdditionalNetworking.Log.LogInfo((object)"host has BoomboxNetworking");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncStateServerRpc(NetworkObjectReference boomboxReference, bool playing, int track)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: 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_0129: 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_0171: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3243193720u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref boomboxReference, default(ForNetworkSerializable));
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref playing, default(ForPrimitives));
					BytePacker.WriteValueBitPacked(val2, track);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3243193720u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val3 = default(ClientRpcParams);
					val3.Send = new ClientRpcSendParams
					{
						TargetClientIds = ValidClientIDs.ToArray()
					};
					ClientRpcParams clientRpcParams = val3;
					AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.SyncStateServerRpc was called for {1}! track: {2}, playing: {3}", "BoomboxNetworking", ((NetworkObjectReference)(ref boomboxReference)).NetworkObjectId, track, playing));
					SyncStateClientRpc(boomboxReference, playing, track, clientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void SyncStateClientRpc(NetworkObjectReference boomboxReference, bool playing, int track, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(2193945042u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref boomboxReference, default(ForNetworkSerializable));
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref playing, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val, track);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 2193945042u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			BoomboxItem component = NetworkObjectReference.op_Implicit(boomboxReference).GetComponent<BoomboxItem>();
			int num = Array.IndexOf(component.musicAudios, component.boomboxAudio.clip);
			bool isPlayingMusic = component.isPlayingMusic;
			AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.SyncStateClientRpc was called for {1}! track: {2}, playing: {3} was track: {4}, playing: {5}", "BoomboxNetworking", ((NetworkObjectReference)(ref boomboxReference)).NetworkObjectId, track, playing, num, isPlayingMusic));
			if (((NetworkBehaviour)component).IsOwner)
			{
				return;
			}
			if (!playing)
			{
				if (isPlayingMusic)
				{
					component.StartMusic(false, false);
				}
			}
			else if (track != -1 && (!isPlayingMusic || num != track))
			{
				component.isPlayingMusic = true;
				((GrabbableObject)component).isBeingUsed = true;
				component.boomboxAudio.Stop();
				component.boomboxAudio.clip = component.musicAudios[track];
				component.boomboxAudio.pitch = 1f;
				component.boomboxAudio.Play();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestSyncServerRpc(NetworkObjectReference shotgunReference, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(1953423010u, serverRpcParams, (RpcDelivery)0);
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref shotgunReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 1953423010u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					AdditionalNetworking.Log.LogDebug((object)$"requestSyncServerRpc was called for {((NetworkObjectReference)(ref shotgunReference)).NetworkObjectId} by {serverRpcParams.Receive.SenderClientId}!");
					BoomboxItem component = NetworkObjectReference.op_Implicit(shotgunReference).GetComponent<BoomboxItem>();
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { serverRpcParams.Receive.SenderClientId }
					};
					ClientRpcParams clientRpcParams = val2;
					int track = Array.IndexOf(component.musicAudios, component.boomboxAudio.clip);
					bool isPlayingMusic = component.isPlayingMusic;
					SyncStateClientRpc(shotgunReference, isPlayingMusic, track, clientRpcParams);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_BoomboxNetworking()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(397310893u, new RpcReceiveHandler(__rpc_handler_397310893));
			NetworkManager.__rpc_func_table.Add(1758458060u, new RpcReceiveHandler(__rpc_handler_1758458060));
			NetworkManager.__rpc_func_table.Add(3243193720u, new RpcReceiveHandler(__rpc_handler_3243193720));
			NetworkManager.__rpc_func_table.Add(2193945042u, new RpcReceiveHandler(__rpc_handler_2193945042));
			NetworkManager.__rpc_func_table.Add(1953423010u, new RpcReceiveHandler(__rpc_handler_1953423010));
		}

		private static void __rpc_handler_397310893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoomboxNetworking)(object)target).OnConnectServerRpc(server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1758458060(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BoomboxNetworking)(object)target).AckConnectClientRpc(client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3243193720(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference boomboxReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref boomboxReference, default(ForNetworkSerializable));
				bool playing = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref playing, default(ForPrimitives));
				int track = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref track);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoomboxNetworking)(object)target).SyncStateServerRpc(boomboxReference, playing, track);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2193945042(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference boomboxReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref boomboxReference, default(ForNetworkSerializable));
				bool playing = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref playing, default(ForPrimitives));
				int track = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref track);
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((BoomboxNetworking)(object)target).SyncStateClientRpc(boomboxReference, playing, track, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1953423010(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference shotgunReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref shotgunReference, default(ForNetworkSerializable));
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoomboxNetworking)(object)target).RequestSyncServerRpc(shotgunReference, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BoomboxNetworking";
		}
	}
	public class PlayerNetworking : NetworkBehaviour
	{
		internal HashSet<ulong> ValidClientIDs = new HashSet<ulong>();

		public static PlayerNetworking Instance { get; private set; }

		public bool Enabled { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			OnConnectServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		public void OnConnectServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2460469972u, serverRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val, 2460469972u, serverRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { serverRpcParams.Receive.SenderClientId }
					};
					ClientRpcParams clientRpcParams = val2;
					AdditionalNetworking.Log.LogInfo((object)string.Format("{0} registered on {1}", serverRpcParams.Receive.SenderClientId, "PlayerNetworking"));
					ValidClientIDs.Add(serverRpcParams.Receive.SenderClientId);
					AckConnectClientRpc(clientRpcParams);
				}
			}
		}

		[ClientRpc]
		private void AckConnectClientRpc(ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(286683517u, clientRpcParams, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val, 286683517u, clientRpcParams, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
				{
					Enabled = true;
					AdditionalNetworking.Log.LogInfo((object)"host has PlayerNetworking");
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncInventoryServerRpc(NetworkObjectReference controllerReference, NetworkObjectReference[] inventory, int[] slots, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: 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_027f: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(535985201u, serverRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = inventory != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(inventory, default(ForNetworkSerializable));
				}
				bool flag2 = slots != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(slots, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 535985201u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			ClientRpcParams val2 = default(ClientRpcParams);
			val2.Send = new ClientRpcSendParams
			{
				TargetClientIds = ValidClientIDs.ToArray()
			};
			ClientRpcParams clientRpcParams = val2;
			AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncInventoryServerRpc was called for {1}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId));
			PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
			List<NetworkObjectReference> list = new List<NetworkObjectReference>();
			List<int> list2 = new List<int>();
			List<NetworkObjectReference> list3 = new List<NetworkObjectReference>();
			for (int i = 0; i < slots.Length; i++)
			{
				if (slots[i] < component.ItemSlots.Length)
				{
					list.Add(inventory[i]);
					list2.Add(slots[i]);
				}
				else
				{
					list3.Add(inventory[i]);
				}
			}
			SyncInventoryClientRpc(controllerReference, list.ToArray(), list2.ToArray(), clientRpcParams);
			if (list3.Count > 0)
			{
				val2 = default(ClientRpcParams);
				val2.Send = new ClientRpcSendParams
				{
					TargetClientIds = new ulong[1] { serverRpcParams.Receive.SenderClientId }
				};
				ClientRpcParams clientRpcParams2 = val2;
				ThrowExtraItemsClientRpc(controllerReference, list3.ToArray(), clientRpcParams2);
			}
		}

		[ClientRpc]
		private void SyncInventoryClientRpc(NetworkObjectReference controllerReference, NetworkObjectReference[] inventory, int[] slots, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1963290541u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = inventory != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(inventory, default(ForNetworkSerializable));
				}
				bool flag2 = slots != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<int>(slots, default(ForPrimitives));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1963290541u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncInventoryClientRpc was called for {1}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId));
			PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
			if (!((NetworkBehaviour)component).IsOwner)
			{
				component.ItemSlots = (GrabbableObject[])(object)new GrabbableObject[component.ItemSlots.Length];
			}
			NetworkObject val3 = default(NetworkObject);
			GrabbableObject val4 = default(GrabbableObject);
			for (int i = 0; i < inventory.Length; i++)
			{
				int num = slots[i];
				NetworkObjectReference val2 = inventory[i];
				if (num >= component.ItemSlots.Length)
				{
					continue;
				}
				if (((NetworkObjectReference)(ref val2)).TryGet(ref val3, (NetworkManager)null) && ((Component)val3).TryGetComponent<GrabbableObject>(ref val4))
				{
					if (!((NetworkBehaviour)component).IsOwner)
					{
						component.ItemSlots[num] = val4;
					}
				}
				else if (!((NetworkBehaviour)component).IsOwner)
				{
					component.ItemSlots[num] = null;
				}
			}
			if (!((NetworkBehaviour)this).IsOwner)
			{
				component.SwitchToItemSlot(component.currentItemSlot, (GrabbableObject)null);
			}
		}

		[ClientRpc]
		private void ThrowExtraItemsClientRpc(NetworkObjectReference controllerReference, NetworkObjectReference[] objectsToThrow, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1911346259u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = objectsToThrow != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(objectsToThrow, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1911346259u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.throwExtraItemsClientRpc was called for {1}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId));
			PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
			if (!((NetworkBehaviour)component).IsOwner)
			{
				return;
			}
			NetworkObject val3 = default(NetworkObject);
			GrabbableObject val4 = default(GrabbableObject);
			for (int i = 0; i < objectsToThrow.Length; i++)
			{
				NetworkObjectReference val2 = objectsToThrow[i];
				if (((NetworkObjectReference)(ref val2)).TryGet(ref val3, (NetworkManager)null) && ((Component)val3).TryGetComponent<GrabbableObject>(ref val4))
				{
					component.ThrowObjectServerRpc(val2, component.isInElevator, component.isInHangarShipRoom, default(Vector3), 0);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncSelectedSlotServerRpc(NetworkObjectReference controllerReference, int selectedSlot)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: 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_0155: 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_0184: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1781763250u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val2, selectedSlot);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1781763250u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
				if (selectedSlot < 0 || selectedSlot >= component.ItemSlots.Length)
				{
					AdditionalNetworking.Log.LogDebug((object)string.Format("Invalid {0}.syncSelectedSlotServerRpc was called for {1}, Ignored! slot:{2}", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId, selectedSlot));
					return;
				}
				ClientRpcParams val3 = default(ClientRpcParams);
				val3.Send = new ClientRpcSendParams
				{
					TargetClientIds = ValidClientIDs.ToArray()
				};
				ClientRpcParams clientRpcParams = val3;
				AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncSelectedSlotServerRpc was called for {1}! slot:{2}", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId, selectedSlot));
				SyncSelectedSlotClientRpc(controllerReference, selectedSlot, clientRpcParams);
			}
		}

		[ClientRpc]
		private void SyncSelectedSlotClientRpc(NetworkObjectReference controllerReference, int selectedSlot, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1459921078u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				BytePacker.WriteValueBitPacked(val, selectedSlot);
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1459921078u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
				AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncSelectedSlotClientRpc was called for {1}! slot:{2} was:{3}", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId, selectedSlot, component.currentItemSlot));
				if (!((NetworkBehaviour)component).IsOwner && component.currentItemSlot != selectedSlot)
				{
					component.SwitchToItemSlot(selectedSlot, (GrabbableObject)null);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void SyncUsernameServerRpc(NetworkObjectReference controllerReference, string username)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: 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_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3417376772u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = username != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe(username, false);
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3417376772u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val3 = default(ClientRpcParams);
				val3.Send = new ClientRpcSendParams
				{
					TargetClientIds = ValidClientIDs.ToArray()
				};
				ClientRpcParams clientRpcParams = val3;
				AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncUsernameServerRpc was called for {1}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId));
				SyncUsernameClientRpc(controllerReference, username, clientRpcParams);
			}
		}

		[ClientRpc]
		public void SyncUsernameClientRpc(NetworkObjectReference controllerReference, string username, ClientRpcParams clientRpcParams = default(ClientRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendClientRpc(1559746131u, clientRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = username != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe(username, false);
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val, 1559746131u, clientRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.syncUsernameClientRpc was called for {1}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId));
			PlayerControllerB controllerB = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
			if (((NetworkBehaviour)controllerB).IsOwner)
			{
				return;
			}
			controllerB.playerUsername = username;
			((TMP_Text)controllerB.usernameBillboardText).text = username;
			StartOfRound.Instance.mapScreen.ChangeNameOfTargetTransform(((Component)controllerB).transform, username);
			if (HUDManager.Instance.spectatingPlayerBoxes.ContainsValue(controllerB))
			{
				GameObject gameObject = ((Component)HUDManager.Instance.spectatingPlayerBoxes.First((KeyValuePair<Animator, PlayerControllerB> x) => (Object)(object)x.Value == (Object)(object)controllerB).Key).gameObject;
				((TMP_Text)gameObject.GetComponentInChildren<TextMeshProUGUI>()).text = username;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestSyncUsernameServerRpc(NetworkObjectReference controllerReference, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0156: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(3259019801u, serverRpcParams, (RpcDelivery)0);
				((FastBufferWriter)(ref val)).WriteValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 3259019801u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				AdditionalNetworking.Log.LogDebug((object)string.Format("{0}.requestSyncUsernameServerRpc was called for {1} by {2}!", "PlayerNetworking", ((NetworkObjectReference)(ref controllerReference)).NetworkObjectId, serverRpcParams.Receive.SenderClientId));
				PlayerControllerB component = NetworkObjectReference.op_Implicit(controllerReference).GetComponent<PlayerControllerB>();
				if (!((NetworkBehaviour)component).IsOwnedByServer)
				{
					ClientRpcParams val2 = default(ClientRpcParams);
					val2.Send = new ClientRpcSendParams
					{
						TargetClientIds = new ulong[1] { serverRpcParams.Receive.SenderClientId }
					};
					ClientRpcParams clientRpcParams = val2;
					SyncUsernameClientRpc(controllerReference, component.playerUsername, clientRpcParams);
				}
			}
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_PlayerNetworking()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(2460469972u, new RpcReceiveHandler(__rpc_handler_2460469972));
			NetworkManager.__rpc_func_table.Add(286683517u, new RpcReceiveHandler(__rpc_handler_286683517));
			NetworkManager.__rpc_func_table.Add(535985201u, new RpcReceiveHandler(__rpc_handler_535985201));
			NetworkManager.__rpc_func_table.Add(1963290541u, new RpcReceiveHandler(__rpc_handler_1963290541));
			NetworkManager.__rpc_func_table.Add(1911346259u, new RpcReceiveHandler(__rpc_handler_1911346259));
			NetworkManager.__rpc_func_table.Add(1781763250u, new RpcReceiveHandler(__rpc_handler_1781763250));
			NetworkManager.__rpc_func_table.Add(1459921078u, new RpcReceiveHandler(__rpc_handler_1459921078));
			NetworkManager.__rpc_func_table.Add(3417376772u, new RpcReceiveHandler(__rpc_handler_3417376772));
			NetworkManager.__rpc_func_table.Add(1559746131u, new RpcReceiveHandler(__rpc_handler_1559746131));
			NetworkManager.__rpc_func_table.Add(3259019801u, new RpcReceiveHandler(__rpc_handler_3259019801));
		}

		private static void __rpc_handler_2460469972(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PlayerNetworking)(object)target).OnConnectServerRpc(server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_286683517(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PlayerNetworking)(object)target).AckConnectClientRpc(client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_535985201(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] inventory = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref inventory, default(ForNetworkSerializable));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				int[] slots = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref slots, default(ForPrimitives));
				}
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PlayerNetworking)(object)target).SyncInventoryServerRpc(controllerReference, inventory, slots, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1963290541(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] inventory = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref inventory, default(ForNetworkSerializable));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				int[] slots = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<int>(ref slots, default(ForPrimitives));
				}
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PlayerNetworking)(object)target).SyncInventoryClientRpc(controllerReference, inventory, slots, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1911346259(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NetworkObjectReference[] objectsToThrow = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref objectsToThrow, default(ForNetworkSerializable));
				}
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PlayerNetworking)(object)target).ThrowExtraItemsClientRpc(controllerReference, objectsToThrow, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1781763250(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				int selectedSlot = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref selectedSlot);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PlayerNetworking)(object)target).SyncSelectedSlotServerRpc(controllerReference, selectedSlot);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1459921078(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				int selectedSlot = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref selectedSlot);
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PlayerNetworking)(object)target).SyncSelectedSlotClientRpc(controllerReference, selectedSlot, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3417376772(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string username = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref username, false);
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PlayerNetworking)(object)target).SyncUsernameServerRpc(controllerReference, username);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1559746131(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				string username = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe(ref username, false);
				}
				ClientRpcParams client = rpcParams.Client;
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PlayerNetworking)(object)target).SyncUsernameClientRpc(controllerReference, username, client);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3259019801(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkObjectReference controllerReference = default(NetworkObjectReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkObjectReference>(ref controllerReference, default(ForNetworkSerializable));
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PlayerNetworking)(object)target).RequestSyncUsernameServerRpc(controllerReference, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "PlayerNetworking";
		}
	}
	public class ShotgunNetworking : NetworkBehaviour
	{
		internal HashSet<ulong> ValidClientIDs = new HashSet<ulong>();

		public static ShotgunNetworking Instance { get; private set; }

		public bool Enabled { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			OnConnectServerRpc();
		}

		[ServerRpc(RequireOwnership = false)]
		public void OnConnectServerRpc(ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: 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_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing