using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dissonance;
using GameNetcodeStuff;
using HarmonyLib;
using JetBrains.Annotations;
using LCPlanAssassin.AssetLoader;
using LCPlanAssassin.Components;
using LCPlanAssassin.Items;
using LCPlanAssassin.NetcodePatcher;
using LCPlanAssassin.Patchers;
using LCPlanAssassin.TarotCard;
using LCPlanAssassin.UI;
using LCPlanAssassin.Utils;
using LCTarrotCard;
using LCTarrotCard.Cards;
using LCTarrotCard.Items;
using LCTarrotCard.Ressource;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: NetcodePatchedAssembly]
namespace LCPlanAssassin
{
	[BepInPlugin("LCPlanAssassin", "Plan d'assassin", "2.7.3")]
	[BepInDependency("LCTarotCard", "1.1.2")]
	public class ModBase : BaseUnityPlugin
	{
		public static ModBase Instance;

		public ManualLogSource logger;

		internal Harmony harmony;

		internal static bool HasError;

		public static KeyboardShortcut TestKey;

		private void Awake()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//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)
			if (!((Object)(object)Instance != (Object)null))
			{
				Instance = this;
				harmony = new Harmony("LCPlanAssassin");
				logger = Logger.CreateLogSource("LCPlanAssassin");
				TestKey = new KeyboardShortcut((KeyCode)96, Array.Empty<KeyCode>());
				Assets.LoadBundles();
				if (!HasError)
				{
					harmony.PatchAll();
					RPC_Init();
					logger.LogInfo((object)"LCPlanAssassin correctly loaded");
				}
			}
		}

		internal static void RPC_Init()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false).Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class Test
	{
		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void TestPatch(PlayerControllerB __instance)
		{
			//IL_003e: 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)
			if (((KeyboardShortcut)(ref ModBase.TestKey)).IsDown() && ((NetworkBehaviour)__instance).IsOwner && ModConstants.TestMode && __instance.isPlayerControlled)
			{
				InstantiateAndReturnGrabbableObject(Assets.CheeseItem.spawnPrefab, ((Component)__instance).transform.position);
				InstantiateAndReturnGrabbableObject(Assets.BolItem.spawnPrefab, ((Component)__instance).transform.position);
			}
		}

		private static GrabbableObject InstantiateAndReturnGrabbableObject(GameObject prefab, Vector3 position)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(prefab, position, Quaternion.identity, RoundManager.Instance.spawnedScrapContainer);
			GrabbableObject component = val.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			component.fallTime = 0f;
			component.scrapValue = 1;
			val.GetComponent<NetworkObject>().Spawn(false);
			return component;
		}
	}
	public static class ModConstants
	{
		public const string MOD_GUID = "LCPlanAssassin";

		public const string MOD_NAME = "Plan d'assassin";

		public const string MOD_VERSION = "2.7.3";

		public static readonly bool TestMode;
	}
}
namespace LCPlanAssassin.AssetLoader
{
	internal static class Assets
	{
		internal static AssetBundle planBundle;

		public static AudioClip EatClip;

		public static readonly List<AudioClip> PlanClips = new List<AudioClip>();

		public static readonly List<AudioClip> KaquiteClips = new List<AudioClip>();

		public static readonly List<AudioClip> KeyboardClips = new List<AudioClip>();

		public static AudioClip LowFan;

		public static AudioClip HighFan;

		public static AudioClip MowStartClip;

		public static AudioClip MowLoopClip;

		public static AudioClip MowEndClip;

		public static Material ScreenOffMat;

		public static Material ScreenOnMat;

		public static VideoClip TranstitionClip;

		public static readonly List<VideoClip> ScreenClips = new List<VideoClip>();

		public static AudioClip Comsau;

		public static List<AudioClip> SpringClips = new List<AudioClip>();

		public static AudioClip RingtoneClip;

		public static List<VideoClip> TelClips = new List<VideoClip>();

		public static Material TelMat;

		public static Material CallingMat;

		public static AudioClip RightClip;

		public static AudioClip WrongClip;

		public static Material WrongMat;

		public static Material RightMat;

		public static AudioClip VacuumStartClip;

		public static AudioClip VacuumLoopClip;

		public static AudioClip VacuumEndClip;

		public static List<AudioClip> FartClips = new List<AudioClip>();

		public static AudioClip SplatClip;

		public static AudioClip FluteClip;

		public static AudioClip JetpackBroken;

		public static AudioClip JetPackThrustStart;

		public static Material OrangeBurn;

		public static AudioClip JeSuisOuClip;

		public static AudioClip TheMoolClip;

		public static List<AudioClip> RotateClips = new List<AudioClip>();

		public static List<AudioClip> SpectrumMusics = new List<AudioClip>();

		public static VideoClip GordionClip;

		public static VideoClip OtherClip;

		public static VideoClip Valo1;

		public static VideoClip Valo2;

		public static VideoClip Planet;

		public static VideoClip TintinClip;

		public static AudioClip TintinAudio;

		public static readonly List<VideoClip> NClips = new List<VideoClip>();

		internal static GameObject JumpscareCanvas;

		public static GameObject JumpscareObj;

		public static readonly List<AudioClip> ScreamClips = new List<AudioClip>();

		public static Item RouterItem;

		public static Item OysterItem;

		public static Item BolItem;

		public static Item BoosterItem;

		public static Item CheeseItem;

		public static List<AudioClip> StomachacheClips = new List<AudioClip>();

		public static Item KkItem;

		public static Item AtiItem;

		public static Item ChopstickItem;

		public static Item FluteItem;

		public static Item LieDetectorItem;

		public static AudioClip LeFauxClip;

		public static Material JsuiouMat;

		public static Material NWordMat;

		public static Material TheMoolMat;

		public static Material SpectrumMat;

		public static Material RotateMat;

		public static Material PlusTardMat;

		public static AudioClip PlusTardClip;

		public static Material DiscoMat;

		public static SpawnRarity PlanRarity;

		public static SpawnRarity SausageTicketRarity;

		public static SpawnRarity PCRarity;

		public static SpawnRarity CasqueRarity;

		public static SpawnRarity HandRarity;

		public static SpawnRarity KeyboardRarity;

		public static SpawnRarity KakahuetRarity;

		public static SpawnRarity MowerRarity;

		public static SpawnRarity ScreenRarity;

		public static SpawnRarity RouterRarity;

		public static SpawnRarity RavcamRarity;

		public static SpawnRarity TelephoneRarity;

		public static SpawnRarity LieDetectorRarity;

		public static SpawnRarity VacuumRarity;

		public static SpawnRarity CheeseRarity;

		public static SpawnRarity FluteRarity;

		public static SpawnRarity ChopstickRarity;

		public static SpawnRarity BolRarity;

		public static SpawnRarity BoosterRarity;

		public static SpawnRarity AtiRarity;

		public static GameObject DiscoBall;

		public static Item PlanAssassin { get; private set; }

		public static Item SausageTicket { get; private set; }

		public static Item Sausage { get; private set; }

		public static Item PCRavix { get; private set; }

		public static Item MicroKaquite { get; private set; }

		public static Item LeftHeadsetItem { get; private set; }

		public static Item RightHeadsetItem { get; private set; }

		public static Item HandItem { get; private set; }

		public static Item KeyboardItem { get; private set; }

		public static Item KakahuetItem { get; private set; }

		public static Item MowerItem { get; private set; }

		public static Item ScreenItem { get; private set; }

		public static Item RavcamItem { get; private set; }

		public static Item TelephoneItem { get; private set; }

		public static Item VacuumItem { get; private set; }

		public static void LoadBundles()
		{
			Stream manifestResourceStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("LCPlanAssassin.Resources.planbundle");
			if (manifestResourceStream == null)
			{
				ModBase.Instance.logger.LogError((object)"Cannot load assets bundle, stream is null");
				ModBase.HasError = true;
				return;
			}
			planBundle = AssetBundle.LoadFromStream(manifestResourceStream);
			if ((Object)(object)planBundle == (Object)null)
			{
				ModBase.Instance.logger.LogError((object)"Cannot load assets bundle, bundle is null");
				ModBase.HasError = true;
			}
			else
			{
				LoadTarotCards();
				LoadAssets();
				InitScraps();
			}
		}

		private static void LoadAssets()
		{
			PlanAssassin = planBundle.LoadAsset<Item>("Assets/PlanAssassin.asset");
			PlanAssassinBehaviour planAssassinBehaviour = PlanAssassin.spawnPrefab.AddComponent<PlanAssassinBehaviour>();
			((GrabbableObject)planAssassinBehaviour).grabbable = true;
			((GrabbableObject)planAssassinBehaviour).grabbableToEnemies = false;
			((GrabbableObject)planAssassinBehaviour).itemProperties = PlanAssassin;
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/ballon.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/cabane.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/camion.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/harbor.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/planassassin.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/temaplan.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/vandal.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/chien.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/monde.ogg"));
			PlanClips.Add(planBundle.LoadAsset<AudioClip>("Assets/SFX/pigeon.ogg"));
			Sausage = planBundle.LoadAsset<Item>("Assets/Sausage.asset");
			SausageBehaviour sausageBehaviour = Sausage.spawnPrefab.AddComponent<SausageBehaviour>();
			((GrabbableObject)sausageBehaviour).grabbable = true;
			((GrabbableObject)sausageBehaviour).grabbableToEnemies = true;
			((GrabbableObject)sausageBehaviour).itemProperties = Sausage;
			PCRavix = planBundle.LoadAsset<Item>("Assets/PC/pc_ravix.asset");
			PcRavixBehaviour pcRavixBehaviour = PCRavix.spawnPrefab.AddComponent<PcRavixBehaviour>();
			((GrabbableObject)pcRavixBehaviour).grabbable = true;
			((GrabbableObject)pcRavixBehaviour).grabbableToEnemies = true;
			((GrabbableObject)pcRavixBehaviour).itemProperties = PCRavix;
			SausageTicket = planBundle.LoadAsset<Item>("Assets/Ticket/ticket.asset");
			SausageTicketBehaviour sausageTicketBehaviour = SausageTicket.spawnPrefab.AddComponent<SausageTicketBehaviour>();
			((GrabbableObject)sausageTicketBehaviour).grabbable = true;
			((GrabbableObject)sausageTicketBehaviour).grabbableToEnemies = true;
			((GrabbableObject)sausageTicketBehaviour).itemProperties = SausageTicket;
			MicroKaquite = planBundle.LoadAsset<Item>("Assets/Micro/casque.asset");
			CasqueBehaviour casqueBehaviour = MicroKaquite.spawnPrefab.AddComponent<CasqueBehaviour>();
			((GrabbableObject)casqueBehaviour).grabbable = true;
			((GrabbableObject)casqueBehaviour).grabbableToEnemies = true;
			((GrabbableObject)casqueBehaviour).itemProperties = MicroKaquite;
			LeftHeadsetItem = planBundle.LoadAsset<Item>("Assets/Micro/casql.asset");
			RightHeadsetItem = planBundle.LoadAsset<Item>("Assets/Micro/casqr.asset");
			HandItem = planBundle.LoadAsset<Item>("Assets/Hand/Hand.asset");
			HandBehaviour handBehaviour = HandItem.spawnPrefab.AddComponent<HandBehaviour>();
			((GrabbableObject)handBehaviour).grabbable = true;
			((GrabbableObject)handBehaviour).grabbableToEnemies = true;
			((GrabbableObject)handBehaviour).itemProperties = HandItem;
			KeyboardItem = planBundle.LoadAsset<Item>("Assets/Clavier/keyboard.asset");
			KeyboardBehaviour keyboardBehaviour = KeyboardItem.spawnPrefab.AddComponent<KeyboardBehaviour>();
			((GrabbableObject)keyboardBehaviour).grabbable = true;
			((GrabbableObject)keyboardBehaviour).grabbableToEnemies = true;
			((GrabbableObject)keyboardBehaviour).itemProperties = KeyboardItem;
			KakahuetItem = planBundle.LoadAsset<Item>("Assets/kakahuet/kakahuet.asset");
			KakahuetBehaviour kakahuetBehaviour = KakahuetItem.spawnPrefab.AddComponent<KakahuetBehaviour>();
			((GrabbableObject)kakahuetBehaviour).grabbable = true;
			((GrabbableObject)kakahuetBehaviour).grabbableToEnemies = true;
			((GrabbableObject)kakahuetBehaviour).itemProperties = KakahuetItem;
			MowerItem = planBundle.LoadAsset<Item>("Assets/mower/mower.asset");
			MowerBehaviour mowerBehaviour = MowerItem.spawnPrefab.AddComponent<MowerBehaviour>();
			((GrabbableObject)mowerBehaviour).grabbable = true;
			((GrabbableObject)mowerBehaviour).grabbableToEnemies = true;
			((GrabbableObject)mowerBehaviour).itemProperties = MowerItem;
			ScreenItem = planBundle.LoadAsset<Item>("Assets/Screen/screen.asset");
			ScreenBehaviour screenBehaviour = ScreenItem.spawnPrefab.AddComponent<ScreenBehaviour>();
			((GrabbableObject)screenBehaviour).grabbable = true;
			((GrabbableObject)screenBehaviour).grabbableToEnemies = true;
			((GrabbableObject)screenBehaviour).itemProperties = ScreenItem;
			ScreenOffMat = planBundle.LoadAsset<Material>("Assets/Screen/ScreenOff.mat");
			ScreenOnMat = planBundle.LoadAsset<Material>("Assets/Screen/ScreenRenderMat.mat");
			TranstitionClip = planBundle.LoadAsset<VideoClip>("Assets/Screen/transition.mp4");
			for (int i = 0; i < 25; i++)
			{
				string text = "Assets/Screen/Clips/cg" + (i + 1) + ".mp4";
				VideoClip item = planBundle.LoadAsset<VideoClip>(text);
				ScreenClips.Add(item);
			}
			RouterItem = planBundle.LoadAsset<Item>("Assets/Router/router.asset");
			RouterBehaviour routerBehaviour = RouterItem.spawnPrefab.AddComponent<RouterBehaviour>();
			((GrabbableObject)routerBehaviour).grabbable = true;
			((GrabbableObject)routerBehaviour).grabbableToEnemies = true;
			((GrabbableObject)routerBehaviour).itemProperties = RouterItem;
			OysterItem = planBundle.LoadAsset<Item>("Assets/PlanTarot/Oyster/themool.asset");
			OysterBehaviour oysterBehaviour = OysterItem.spawnPrefab.AddComponent<OysterBehaviour>();
			((GrabbableObject)oysterBehaviour).grabbable = true;
			((GrabbableObject)oysterBehaviour).grabbableToEnemies = true;
			((GrabbableObject)oysterBehaviour).itemProperties = OysterItem;
			RavcamItem = planBundle.LoadAsset<Item>("Assets/Ravcam/ravixcam.asset");
			RavcamBehaviour ravcamBehaviour = RavcamItem.spawnPrefab.AddComponent<RavcamBehaviour>();
			((GrabbableObject)ravcamBehaviour).grabbable = true;
			((GrabbableObject)ravcamBehaviour).grabbableToEnemies = true;
			((GrabbableObject)ravcamBehaviour).itemProperties = RavcamItem;
			for (int j = 0; j < 3; j++)
			{
				SpringClips.Add(planBundle.LoadAsset<AudioClip>("Assets/Ravcam/sp" + j + ".mp3"));
			}
			TelephoneItem = planBundle.LoadAsset<Item>("Assets/Telephone/telephone.asset");
			TelephoneBehaviour telephoneBehaviour = TelephoneItem.spawnPrefab.AddComponent<TelephoneBehaviour>();
			((GrabbableObject)telephoneBehaviour).grabbable = true;
			((GrabbableObject)telephoneBehaviour).grabbableToEnemies = true;
			((GrabbableObject)telephoneBehaviour).itemProperties = TelephoneItem;
			RingtoneClip = planBundle.LoadAsset<AudioClip>("Assets/Telephone/Clips/ling.mp3");
			for (int k = 0; k < 5; k++)
			{
				TelClips.Add(planBundle.LoadAsset<VideoClip>("Assets/Telephone/Clips/v" + k + ".mp4"));
			}
			TelMat = planBundle.LoadAsset<Material>("Assets/Telephone/TelScreenMat.mat");
			CallingMat = planBundle.LoadAsset<Material>("Assets/Telephone/calling.mat");
			LieDetectorItem = planBundle.LoadAsset<Item>("Assets/Lie/liedetec.asset");
			LieDetectorBehaviour lieDetectorBehaviour = LieDetectorItem.spawnPrefab.AddComponent<LieDetectorBehaviour>();
			((GrabbableObject)lieDetectorBehaviour).grabbable = true;
			((GrabbableObject)lieDetectorBehaviour).grabbableToEnemies = true;
			((GrabbableObject)lieDetectorBehaviour).itemProperties = LieDetectorItem;
			RightClip = planBundle.LoadAsset<AudioClip>("Assets/Lie/correct.ogg");
			WrongClip = planBundle.LoadAsset<AudioClip>("Assets/Lie/wrong.ogg");
			WrongMat = planBundle.LoadAsset<Material>("Assets/Lie/wrong.mat");
			RightMat = planBundle.LoadAsset<Material>("Assets/Lie/right.mat");
			VacuumItem = planBundle.LoadAsset<Item>("Assets/Aspi/aspi.asset");
			AspiBehaviour aspiBehaviour = VacuumItem.spawnPrefab.AddComponent<AspiBehaviour>();
			((GrabbableObject)aspiBehaviour).grabbable = true;
			((GrabbableObject)aspiBehaviour).grabbableToEnemies = true;
			((GrabbableObject)aspiBehaviour).itemProperties = VacuumItem;
			CheeseItem = planBundle.LoadAsset<Item>("Assets/Cheese/cheese_item.asset");
			CheeseBehaviour cheeseBehaviour = CheeseItem.spawnPrefab.AddComponent<CheeseBehaviour>();
			((GrabbableObject)cheeseBehaviour).grabbable = true;
			((GrabbableObject)cheeseBehaviour).grabbableToEnemies = true;
			((GrabbableObject)cheeseBehaviour).itemProperties = CheeseItem;
			KkItem = planBundle.LoadAsset<Item>("Assets/Cheese/kk_item.asset");
			KkBehaviour kkBehaviour = KkItem.spawnPrefab.AddComponent<KkBehaviour>();
			((GrabbableObject)kkBehaviour).grabbable = true;
			((GrabbableObject)kkBehaviour).grabbableToEnemies = true;
			((GrabbableObject)kkBehaviour).itemProperties = KkItem;
			SplatClip = planBundle.LoadAsset<AudioClip>("Assets/Cheese/splat.ogg");
			ChopstickItem = planBundle.LoadAsset<Item>("Assets/ChopSticks/chopsticks.asset");
			ChopstickBehaviour chopstickBehaviour = ChopstickItem.spawnPrefab.AddComponent<ChopstickBehaviour>();
			((GrabbableObject)chopstickBehaviour).grabbable = true;
			((GrabbableObject)chopstickBehaviour).grabbableToEnemies = true;
			((GrabbableObject)chopstickBehaviour).itemProperties = ChopstickItem;
			FluteItem = planBundle.LoadAsset<Item>("Assets/Flute/flute_item.asset");
			FluteBehaviour fluteBehaviour = FluteItem.spawnPrefab.AddComponent<FluteBehaviour>();
			((GrabbableObject)fluteBehaviour).grabbable = true;
			((GrabbableObject)fluteBehaviour).grabbableToEnemies = true;
			((GrabbableObject)fluteBehaviour).itemProperties = FluteItem;
			FluteClip = planBundle.LoadAsset<AudioClip>("Assets/Flute/dj.ogg");
			BolItem = planBundle.LoadAsset<Item>("Assets/Ravix/Bol/bol.asset");
			BolBehaviour bolBehaviour = BolItem.spawnPrefab.AddComponent<BolBehaviour>();
			((GrabbableObject)bolBehaviour).grabbable = true;
			((GrabbableObject)bolBehaviour).grabbableToEnemies = true;
			((GrabbableObject)bolBehaviour).itemProperties = BolItem;
			BoosterItem = planBundle.LoadAsset<Item>("Assets/Ravix/Booster/Booster.asset");
			BoosterBehaviour boosterBehaviour = BoosterItem.spawnPrefab.AddComponent<BoosterBehaviour>();
			((GrabbableObject)boosterBehaviour).grabbable = true;
			((GrabbableObject)boosterBehaviour).grabbableToEnemies = true;
			((GrabbableObject)boosterBehaviour).itemProperties = BoosterItem;
			JetpackBroken = planBundle.LoadAsset<AudioClip>("Assets/Ravix/Booster/JetpackBroken.wav");
			JetPackThrustStart = planBundle.LoadAsset<AudioClip>("Assets/Ravix/Booster/JetPackThrustStart.wav");
			AtiItem = planBundle.LoadAsset<Item>("Assets/Ravix/ATI/ati.asset");
			AtiBehaviour atiBehaviour = AtiItem.spawnPrefab.AddComponent<AtiBehaviour>();
			((GrabbableObject)atiBehaviour).grabbable = true;
			((GrabbableObject)atiBehaviour).grabbableToEnemies = true;
			((GrabbableObject)atiBehaviour).itemProperties = AtiItem;
			VacuumStartClip = planBundle.LoadAsset<AudioClip>("Assets/Aspi/vac_start.ogg");
			VacuumLoopClip = planBundle.LoadAsset<AudioClip>("Assets/Aspi/vac_loop.ogg");
			VacuumEndClip = planBundle.LoadAsset<AudioClip>("Assets/Aspi/vac_end.ogg");
			JsuiouMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/JsuiouMat.mat");
			NWordMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/nwordMat.mat");
			TheMoolMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/themoolMat.mat");
			SpectrumMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Spectrum/SpecMat.mat");
			RotateMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/360Mat.mat");
			RotateClips.Add(planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Audio/aso36.ogg"));
			RotateClips.Add(planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Audio/tomo36.ogg"));
			OrangeBurn = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/OrangeBurn.mat");
			JeSuisOuClip = planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Audio/jsuiou.ogg");
			TheMoolClip = planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Audio/themool.ogg");
			for (int l = 0; l < 6; l++)
			{
				SpectrumMusics.Add(planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Spectrum/s" + (l + 1) + ".mp3"));
			}
			EatClip = planBundle.LoadAsset<AudioClip>("Assets/nomnom.ogg");
			Comsau = planBundle.LoadAsset<AudioClip>("Assets/comsau.mp3");
			GordionClip = planBundle.LoadAsset<VideoClip>("Assets/scout.mp4");
			OtherClip = planBundle.LoadAsset<VideoClip>("Assets/roblox.mp4");
			Valo1 = planBundle.LoadAsset<VideoClip>("Assets/val1.mp4");
			Valo2 = planBundle.LoadAsset<VideoClip>("Assets/val2.mp4");
			Planet = planBundle.LoadAsset<VideoClip>("Assets/plan1.mp4");
			TintinClip = planBundle.LoadAsset<VideoClip>("Assets/dupon.mp4");
			TintinAudio = planBundle.LoadAsset<AudioClip>("Assets/tintin.mp3");
			LowFan = planBundle.LoadAsset<AudioClip>("Assets/PC/fan_low.ogg");
			HighFan = planBundle.LoadAsset<AudioClip>("Assets/PC/fan_high.ogg");
			HandBehaviour.RiseSfx = planBundle.LoadAsset<AudioClip>("Assets/Hand/rise.ogg");
			HandBehaviour.FunnySfx = planBundle.LoadAsset<AudioClip>("Assets/Hand/funny.ogg");
			HandBehaviour.DownSfx = planBundle.LoadAsset<AudioClip>("Assets/Hand/down.ogg");
			for (int m = 0; m < 7; m++)
			{
				string text2 = "Assets/Micro/p" + (m + 1) + ".ogg";
				AudioClip item2 = planBundle.LoadAsset<AudioClip>(text2);
				KaquiteClips.Add(item2);
			}
			MowStartClip = planBundle.LoadAsset<AudioClip>("Assets/mower/mow_start.ogg");
			MowLoopClip = planBundle.LoadAsset<AudioClip>("Assets/mower/mow_loop.ogg");
			MowEndClip = planBundle.LoadAsset<AudioClip>("Assets/mower/mow_stop.ogg");
			for (int n = 0; n < 5; n++)
			{
				string text3 = "Assets/Clavier/cl" + (n + 1) + ".ogg";
				AudioClip item3 = planBundle.LoadAsset<AudioClip>(text3);
				KeyboardClips.Add(item3);
			}
			for (int num = 0; num < 3; num++)
			{
				string text4 = "Assets/Cheese/s" + (num + 1) + ".ogg";
				AudioClip item4 = planBundle.LoadAsset<AudioClip>(text4);
				StomachacheClips.Add(item4);
			}
			FartClips.Add(planBundle.LoadAsset<AudioClip>("Assets/Cheese/F1.mp3"));
			FartClips.Add(planBundle.LoadAsset<AudioClip>("Assets/Cheese/F1.mp3"));
			NClips.Add(planBundle.LoadAsset<VideoClip>("Assets/PlanTarot/Jumpscare/nga.mp4"));
			NClips.Add(planBundle.LoadAsset<VideoClip>("Assets/PlanTarot/Jumpscare/nword.mp4"));
			NClips.Add(planBundle.LoadAsset<VideoClip>("Assets/PlanTarot/Jumpscare/nword1.mp4"));
			NClips.Add(planBundle.LoadAsset<VideoClip>("Assets/PlanTarot/Jumpscare/nword2.mp4"));
			JumpscareCanvas = planBundle.LoadAsset<GameObject>("Assets/PlanTarot/Jumpscare/JumpscareCanvas.prefab");
			JumpscareCanvas.AddComponent<Jumpscare>();
			for (int num2 = 0; num2 < 6; num2++)
			{
				ScreamClips.Add(planBundle.LoadAsset<AudioClip>("Assets/Scream/s" + (num2 + 1) + ".ogg"));
			}
			PlusTardMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/PlustardMat.mat");
			PlusTardClip = planBundle.LoadAsset<AudioClip>("Assets/PlanTarot/Audio/plustard.mp3");
			DiscoMat = planBundle.LoadAsset<Material>("Assets/PlanTarot/Mats/DiscoMat.mat");
			LeFauxClip = planBundle.LoadAsset<AudioClip>("Assets/faux.ogg");
		}

		private static void InitScraps()
		{
			PlanRarity = new SpawnRarity(10, PlanAssassin);
			PlanRarity.SetValues(-1, -1, 15, 35, 20, -1, 30, 30, 60, 50, 25);
			SausageTicketRarity = new SpawnRarity(20, SausageTicket);
			SausageTicketRarity.SetValues(15, -1, -1, 25, -1, 17, 30, 33, 45, 50);
			PCRarity = new SpawnRarity(9, PCRavix);
			PCRarity.SetValues(-1, 10, -1, 15, -1, 13, 22, 25, 40, 44, 40);
			CasqueRarity = new SpawnRarity(15, MicroKaquite);
			CasqueRarity.SetValues(10, -1, 13, 22, -1, 22, 20, 20, 40, 26, 33);
			HandRarity = new SpawnRarity(7, HandItem);
			HandRarity.SetValues(10, 15, 15, 40, -1, 30, 13, 10, 10, 35, 20);
			KeyboardRarity = new SpawnRarity(13, KeyboardItem);
			KeyboardRarity.SetValues(7, -1, 15, 20, 15, -1, 20, 25, 35, 35, 25);
			KakahuetRarity = new SpawnRarity(23, KakahuetItem);
			KakahuetRarity.SetValues(-1, -1, 25, 30, 30, -1, 30, 30, 35, 40);
			MowerRarity = new SpawnRarity(10, MowerItem);
			MowerRarity.SetValues(4, -1, 15, 15, 11, -1, 20, 25, 30, 28, 20);
			ScreenRarity = new SpawnRarity(12, ScreenItem);
			ScreenRarity.SetValues(5, 13, 15, 18, -1, 18, 19, 25, 20, 30);
			RouterRarity = new SpawnRarity(10, RouterItem);
			RouterRarity.CopyRaritiesFrom(KeyboardRarity);
			RavcamRarity = new SpawnRarity(15, RavcamItem);
			RavcamRarity.SetValues(10, -1, 15, 20, 15, -1, 20, 25, 35, 35, 25);
			TelephoneRarity = new SpawnRarity(10, TelephoneItem);
			TelephoneRarity.CopyRaritiesFrom(ScreenRarity);
			LieDetectorRarity = new SpawnRarity(10, LieDetectorItem);
			LieDetectorRarity.CopyRaritiesFrom(ScreenRarity);
			VacuumRarity = new SpawnRarity(15, VacuumItem);
			VacuumRarity.CopyRaritiesFrom(MowerRarity);
			CheeseRarity = new SpawnRarity(20, CheeseItem);
			CheeseRarity.CopyRaritiesFrom(SausageTicketRarity);
			FluteRarity = new SpawnRarity(7, FluteItem);
			FluteRarity.CopyRaritiesFrom(HandRarity);
			ChopstickRarity = new SpawnRarity(5, ChopstickItem);
			ChopstickRarity.CopyRaritiesFrom(RavcamRarity);
			ChopstickRarity.Multiply(2f);
			BolRarity = new SpawnRarity(15, BolItem);
			BolRarity.CopyRaritiesFrom(HandRarity);
			BoosterRarity = new SpawnRarity(8, BoosterItem);
			BoosterRarity.SetValues(-1, -1, -1, 12, 15, 10, 15, 17, 35, 22, 35);
			AtiRarity = new SpawnRarity(10, AtiItem);
			AtiRarity.CopyRaritiesFrom(RouterRarity);
		}

		private static void LoadTarotCards()
		{
			AllCards.RegisterCard(typeof(JsuisouCard), 2);
			AllCards.RegisterCard(typeof(NWordCard), 3);
			AllCards.RegisterCard(typeof(SpectrumCard), 5);
			AllCards.RegisterCard(typeof(RotateCard), 4);
			AllCards.RegisterCard(typeof(PlusTardCard), 4);
			AllCards.RegisterCard(typeof(DiscoCard), 5);
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class NetworkPatcher
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void RegisterItems()
		{
			NetworkManager component = ((Component)GameNetworkManager.Instance).GetComponent<NetworkManager>();
			component.AddNetworkPrefab(Assets.PlanAssassin.spawnPrefab);
			component.AddNetworkPrefab(Assets.Sausage.spawnPrefab);
			component.AddNetworkPrefab(Assets.PCRavix.spawnPrefab);
			component.AddNetworkPrefab(Assets.SausageTicket.spawnPrefab);
			component.AddNetworkPrefab(Assets.MicroKaquite.spawnPrefab);
			component.AddNetworkPrefab(Assets.LeftHeadsetItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.RightHeadsetItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.HandItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.KakahuetItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.KeyboardItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.MowerItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.ScreenItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.RouterItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.OysterItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.RavcamItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.TelephoneItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.LieDetectorItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.VacuumItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.CheeseItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.KkItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.ChopstickItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.FluteItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.BolItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.BoosterItem.spawnPrefab);
			component.AddNetworkPrefab(Assets.AtiItem.spawnPrefab);
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRoundPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void InstantiateJump()
		{
			Assets.JumpscareObj = Object.Instantiate<GameObject>(Assets.JumpscareCanvas);
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AddScrapItem(StartOfRound __instance)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			using (IEnumerator<UnlockableItem> enumerator = __instance.unlockablesList.unlockables.Where((UnlockableItem unlockable) => unlockable.unlockableName == "Disco Ball").GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					UnlockableItem current = enumerator.Current;
					Assets.DiscoBall = Object.Instantiate<GameObject>(current.prefabObject, (Transform)null, true);
					Assets.DiscoBall.transform.position = new Vector3(0f, -1000f, 0f);
					((Behaviour)Assets.DiscoBall.GetComponent<AutoParentToShip>()).enabled = false;
					((Behaviour)Assets.DiscoBall.GetComponentInChildren<CozyLights>()).enabled = false;
					((Behaviour)Assets.DiscoBall.GetComponentInChildren<Animator>()).enabled = false;
					((Component)Assets.DiscoBall.transform.GetChild(1)).gameObject.SetActive(false);
					((Renderer)((Component)Assets.DiscoBall.transform.GetChild(0).GetChild(0)).gameObject.GetComponent<MeshRenderer>()).enabled = false;
				}
			}
			SelectableLevel[] levels = __instance.levels;
			foreach (SelectableLevel val in levels)
			{
				switch (val.levelID)
				{
				case 2:
					val.videoReel = Assets.Valo1;
					break;
				case 3:
					val.videoReel = Assets.GordionClip;
					break;
				case 5:
					val.videoReel = Assets.OtherClip;
					break;
				case 7:
					val.videoReel = Assets.Valo2;
					break;
				case 9:
					val.videoReel = Assets.Planet;
					break;
				}
				Assets.PlanRarity.ApplySpawnRarity(val);
				Assets.SausageTicketRarity.ApplySpawnRarity(val);
				Assets.PCRarity.ApplySpawnRarity(val);
				Assets.CasqueRarity.ApplySpawnRarity(val);
				Assets.HandRarity.ApplySpawnRarity(val);
				Assets.KeyboardRarity.ApplySpawnRarity(val);
				Assets.KakahuetRarity.ApplySpawnRarity(val);
				Assets.MowerRarity.ApplySpawnRarity(val);
				Assets.ScreenRarity.ApplySpawnRarity(val);
				Assets.RouterRarity.ApplySpawnRarity(val);
				Assets.RavcamRarity.ApplySpawnRarity(val);
				Assets.TelephoneRarity.ApplySpawnRarity(val);
				Assets.LieDetectorRarity.ApplySpawnRarity(val);
				Assets.VacuumRarity.ApplySpawnRarity(val);
				Assets.CheeseRarity.ApplySpawnRarity(val);
				Assets.FluteRarity.ApplySpawnRarity(val);
				Assets.ChopstickRarity.ApplySpawnRarity(val);
				Assets.BolRarity.ApplySpawnRarity(val);
				Assets.BoosterRarity.ApplySpawnRarity(val);
				Assets.AtiRarity.ApplySpawnRarity(val);
			}
			RegisterItem(Assets.PlanAssassin, __instance);
			RegisterItem(Assets.Sausage, __instance);
			RegisterItem(Assets.PCRavix, __instance);
			RegisterItem(Assets.SausageTicket, __instance);
			RegisterItem(Assets.MicroKaquite, __instance);
			RegisterItem(Assets.LeftHeadsetItem, __instance);
			RegisterItem(Assets.RightHeadsetItem, __instance);
			RegisterItem(Assets.HandItem, __instance);
			RegisterItem(Assets.KeyboardItem, __instance);
			RegisterItem(Assets.KakahuetItem, __instance);
			RegisterItem(Assets.MowerItem, __instance);
			RegisterItem(Assets.ScreenItem, __instance);
			RegisterItem(Assets.RouterItem, __instance);
			RegisterItem(Assets.OysterItem, __instance);
			RegisterItem(Assets.RavcamItem, __instance);
			RegisterItem(Assets.TelephoneItem, __instance);
			RegisterItem(Assets.LieDetectorItem, __instance);
			RegisterItem(Assets.VacuumItem, __instance);
			RegisterItem(Assets.CheeseItem, __instance);
			RegisterItem(Assets.KkItem, __instance);
			RegisterItem(Assets.ChopstickItem, __instance);
			RegisterItem(Assets.FluteItem, __instance);
			RegisterItem(Assets.BolItem, __instance);
			RegisterItem(Assets.BoosterItem, __instance);
			RegisterItem(Assets.AtiItem, __instance);
		}

		private static void RegisterItem(Item item, StartOfRound manager)
		{
			if (!manager.allItemsList.itemsList.Contains(item))
			{
				manager.allItemsList.itemsList.Add(item);
			}
		}
	}
}
namespace LCPlanAssassin.Items
{
	public class AspiBehaviour : NoisemakerProp
	{
		[CompilerGenerated]
		private sealed class <StartVacuumCoroutine>d__10 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AspiBehaviour <>4__this;

			private float <deltaTime>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <StartVacuumCoroutine>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (<>4__this.isOn)
					{
						return false;
					}
					<>4__this.isOn = true;
					<>4__this.itemAudio.PlayOneShot(Assets.VacuumStartClip);
					<>2__current = (object)new WaitForSeconds(Assets.VacuumStartClip.length - 0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.loopSource.Play();
					<>4__this.loopSource.volume = 0f;
					<deltaTime>5__1 = 0f;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if ((double)<deltaTime>5__1 < 0.2)
				{
					<>4__this.loopSource.volume = <deltaTime>5__1 / 0.2f;
					<deltaTime>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				<>4__this.loopSource.volume = 1f;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <StopVacuumCoroutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AspiBehaviour <>4__this;

			private float <deltaTime>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <StopVacuumCoroutine>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!<>4__this.isOn)
					{
						return false;
					}
					<>4__this.isOn = false;
					<>4__this.itemAudio.volume = 0.5f;
					<>4__this.itemAudio.PlayOneShot(Assets.VacuumEndClip);
					<>4__this.loopSource.volume = 1f;
					<deltaTime>5__1 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((double)<deltaTime>5__1 < 0.25)
				{
					<>4__this.loopSource.volume = (float)(1.0 - (double)<deltaTime>5__1 / 0.25);
					<>4__this.itemAudio.volume = Mathf.Lerp(0.5f, 1f, <deltaTime>5__1 / 0.25f);
					<deltaTime>5__1 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.loopSource.Stop();
				<>4__this.loopSource.volume = 1f;
				<>4__this.itemAudio.volume = 1f;
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private AudioSource itemAudio;

		private AudioSource loopSource;

		private Transform suckPoint;

		private bool isOn;

		private float lastUse;

		private readonly float suckForce = 6f;

		private readonly float suckRange = 5f;

		public override void Start()
		{
			((NoisemakerProp)this).Start();
			itemAudio = ((Component)this).gameObject.GetComponent<AudioSource>();
			((Component)itemAudio).gameObject.AddComponent<AudioDistortionFilter>().distortionLevel = 0.6f;
			loopSource = ((Component)this).gameObject.AddComponent<AudioSource>();
			loopSource.volume = 1f;
			loopSource.spatialBlend = 1f;
			loopSource.dopplerLevel = 0.45f;
			loopSource.spread = 45f;
			loopSource.rolloffMode = (AudioRolloffMode)1;
			loopSource.minDistance = 3f;
			loopSource.maxDistance = 60f;
			loopSource.loop = true;
			loopSource.clip = Assets.VacuumLoopClip;
			suckPoint = ((Component)this).gameObject.transform.GetChild(2);
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (((NetworkBehaviour)this).IsOwner && buttonDown && !((double)Time.time - (double)lastUse < 5.0))
			{
				lastUse = Time.time;
				UseItemServerRpc();
			}
		}

		public override void Update()
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: 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_00dd: 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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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_0113: 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)
			((GrabbableObject)this).Update();
			((GrabbableObject)this).useCooldown = (((double)(Time.time - lastUse) >= 5.0) ? 0f : 10f);
			if (!isOn)
			{
				return;
			}
			PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
			if (Object.op_Implicit((Object)(object)localPlayerController) && localPlayerController.isPlayerControlled && !localPlayerController.isPlayerDead && (!Object.op_Implicit((Object)(object)((GrabbableObject)this).playerHeldBy) || localPlayerController.playerClientId != ((GrabbableObject)this).playerHeldBy.playerClientId))
			{
				float num = Vector3.Distance(((Component)localPlayerController).transform.position, suckPoint.position);
				if (!(num > suckRange))
				{
					Vector3 val = suckPoint.position - ((Component)localPlayerController).transform.position;
					Vector3 val2 = ((Vector3)(ref val)).normalized * (suckForce * (float)(1.0 - (double)(num / suckRange)));
					localPlayerController.externalForces += val2;
				}
			}
		}

		[IteratorStateMachine(typeof(<StartVacuumCoroutine>d__10))]
		private IEnumerator StartVacuumCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartVacuumCoroutine>d__10(0)
			{
				<>4__this = this
			};
		}

		[IteratorStateMachine(typeof(<StopVacuumCoroutine>d__11))]
		private IEnumerator StopVacuumCoroutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StopVacuumCoroutine>d__11(0)
			{
				<>4__this = this
			};
		}

		[ServerRpc(RequireOwnership = false)]
		private void UseItemServerRpc()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2950870372u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2950870372u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					SetStateClientRpc(!isOn);
				}
			}
		}

		[ClientRpc]
		private void SetStateClientRpc(bool state)
		{
			//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_00dc: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3699694096u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref state, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3699694096u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					((MonoBehaviour)this).StartCoroutine(state ? StartVacuumCoroutine() : StopVacuumCoroutine());
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2950870372u, new RpcReceiveHandler(__rpc_handler_2950870372), "UseItemServerRpc");
			((NetworkBehaviour)this).__registerRpc(3699694096u, new RpcReceiveHandler(__rpc_handler_3699694096), "SetStateClientRpc");
			((NoisemakerProp)this).__initializeRpcs();
		}

		private static void __rpc_handler_2950870372(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((AspiBehaviour)(object)target).UseItemServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3699694096(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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool stateClientRpc = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref stateClientRpc, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((AspiBehaviour)(object)target).SetStateClientRpc(stateClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "AspiBehaviour";
		}
	}
	public class AtiBehaviour : GrabbableObject
	{
		[CompilerGenerated]
		private sealed class <LowFPSCoroutine>d__2 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public LowFPSComponent component;

			public AtiBehaviour <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LowFPSCoroutine>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					component.SetActive(active: true);
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private PlayerControllerB previousHolder;

		public override void GrabItem()
		{
			((GrabbableObject)this).GrabItem();
			if (Object.op_Implicit((Object)(object)base.playerHeldBy) && !base.playerHeldBy.isPlayerDead && base.playerHeldBy.isPlayerControlled && !((Object)(object)base.playerHeldBy != (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				if (!Object.op_Implicit((Object)(object)((Component)base.playerHeldBy).gameObject.GetComponent<LowFPSComponent>()))
				{
					((Component)base.playerHeldBy).gameObject.AddComponent<LowFPSComponent>();
				}
				LowFPSComponent component = ((Component)base.playerHeldBy).gameObject.GetComponent<LowFPSComponent>();
				component.targetFPS = 10;
				((MonoBehaviour)this).StartCoroutine(LowFPSCoroutine(component));
				previousHolder = base.playerHeldBy;
			}
		}

		[IteratorStateMachine(typeof(<LowFPSCoroutine>d__2))]
		private IEnumerator LowFPSCoroutine(LowFPSComponent component)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LowFPSCoroutine>d__2(0)
			{
				<>4__this = this,
				component = component
			};
		}

		public override void DiscardItem()
		{
			((GrabbableObject)this).DiscardItem();
			if (Object.op_Implicit((Object)(object)previousHolder) && !previousHolder.isPlayerDead && previousHolder.isPlayerControlled && !((Object)(object)previousHolder != (Object)(object)GameNetworkManager.Instance.localPlayerController))
			{
				LowFPSComponent component = ((Component)previousHolder).gameObject.GetComponent<LowFPSComponent>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.SetActive(active: false);
					previousHolder = null;
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			((GrabbableObject)this).__initializeRpcs();
		}

		protected internal override string __getTypeName()
		{
			return "AtiBehaviour";
		}
	}
	public class BolBehaviour : GrabbableObject
	{
		private AudioSource source;

		public override void Start()
		{
			((GrabbableObject)this).Start();
			source = ((Component)this).gameObject.GetComponent<AudioSource>();
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (((NetworkBehaviour)this).IsOwner && !base.deactivated && buttonDown && base.isHeld && !((Object)(object)base.playerHeldBy == (Object)null))
			{
				UseItemServerRpc();
			}
		}

		public override void PlayDropSFX()
		{
			if (!((Behaviour)this).enabled)
			{
				base.hasHitGround = true;
			}
			else
			{
				((GrabbableObject)this).PlayDropSFX();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void UseItemServerRpc()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1859503350u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1859503350u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UseItemClientRpc();
				}
			}
		}

		[ClientRpc]
		public void UseItemClientRpc()
		{
			//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_00c1: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1442989681u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1442989681u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				source.PlayOneShot(Assets.EatClip);
				PlayerControllerBPatch.SausageDict[base.playerHeldBy.playerClientId] = Time.time;
				if ((Object)(object)base.playerHeldBy == (Object)(object)GameNetworkManager.Instance.localPlayerController)
				{
					AddShieldServerRpc((int)base.playerHeldBy.playerClientId);
					HUDManager.Instance.DisplayTip("Shield", "Vous avez un bouclier en plus", false, false, "LC_Tip1");
				}
				((Behaviour)this).enabled = false;
				((GrabbableObject)this).DestroyObjectInHand(base.playerHeldBy);
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void AddShieldServerRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1324677713u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerId);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1324677713u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					AddShieldClientRpc(playerId);
				}
			}
		}

		[ClientRpc]
		public void AddShieldClientRpc(int playerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2802635675u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2802635675u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (PlayerControllerBPatch.ShieldDict.ContainsKey((ulong)playerId))
				{
					PlayerControllerBPatch.ShieldDict[(ulong)playerId]++;
				}
				else
				{
					PlayerControllerBPatch.ShieldDict.Add((ulong)playerId, 1);
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1859503350u, new RpcReceiveHandler(__rpc_handler_1859503350), "UseItemServerRpc");
			((NetworkBehaviour)this).__registerRpc(1442989681u, new RpcReceiveHandler(__rpc_handler_1442989681), "UseItemClientRpc");
			((NetworkBehaviour)this).__registerRpc(1324677713u, new RpcReceiveHandler(__rpc_handler_1324677713), "AddShieldServerRpc");
			((NetworkBehaviour)this).__registerRpc(2802635675u, new RpcReceiveHandler(__rpc_handler_2802635675), "AddShieldClientRpc");
			((GrabbableObject)this).__initializeRpcs();
		}

		private static void __rpc_handler_1859503350(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BolBehaviour)(object)target).UseItemServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1442989681(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BolBehaviour)(object)target).UseItemClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1324677713(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BolBehaviour)(object)target).AddShieldServerRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2802635675(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int playerId = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref playerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BolBehaviour)(object)target).AddShieldClientRpc(playerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BolBehaviour";
		}
	}
	public class BoosterBehaviour : GrabbableObject
	{
		private AudioSource audioSource;

		public bool active;

		public float fuel = 100f;

		public float power = 1f;

		public bool broken;

		private Vector3 force = Vector3.zero;

		private readonly float acceleration = 10f;

		public override void Start()
		{
			((GrabbableObject)this).Start();
			audioSource = ((Component)this).GetComponent<AudioSource>();
			audioSource.loop = true;
		}

		public override void Update()
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: 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_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			((GrabbableObject)this).Update();
			if (!((NetworkBehaviour)this).IsOwner)
			{
				return;
			}
			if ((double)fuel <= 0.0)
			{
				if (active)
				{
					ActivateBoosterServerRpc(activate: false);
				}
			}
			else if (!((Object)(object)base.playerHeldBy == (Object)null))
			{
				if (active)
				{
					power = Mathf.Clamp(power + Time.deltaTime * acceleration, 1f, 100f);
					force = Vector3.Lerp(force, ((Component)base.playerHeldBy).transform.up * power, Time.deltaTime * acceleration);
					fuel -= Time.deltaTime * (power / 5f);
				}
				else
				{
					power = 0f;
					force = Vector3.zero;
				}
				RaycastHit val = default(RaycastHit);
				if (!base.playerHeldBy.isPlayerDead && Physics.Raycast(((Component)base.playerHeldBy).transform.position, force, ref val, 25f, StartOfRound.Instance.allPlayersCollideWithMask, (QueryTriggerInteraction)1) && (double)(((Vector3)(ref force)).magnitude - ((RaycastHit)(ref val)).distance) > 50.0 && (double)((RaycastHit)(ref val)).distance < 4.0)
				{
					base.playerHeldBy.KillPlayer(force, true, (CauseOfDeath)16, 0, default(Vector3), false);
				}
				PlayerControllerB playerHeldBy = base.playerHeldBy;
				playerHeldBy.externalForces += force;
			}
		}

		public override void OnHitGround()
		{
			((GrabbableObject)this).OnHitGround();
			if (active)
			{
				ActivateBoosterServerRpc(activate: false);
				audioSource.Stop();
				ExplodeBoosterServerRpc();
			}
		}

		public override void DiscardItem()
		{
			if (((NetworkBehaviour)this).IsOwner && base.playerHeldBy.isPlayerDead && !broken && base.playerHeldBy.jetpackControls)
			{
				ActivateBoosterServerRpc(activate: false);
				ExplodeBoosterServerRpc();
			}
			if (base.playerHeldBy.jetpackControls)
			{
				base.playerHeldBy.disablingJetpackControls = true;
			}
			((GrabbableObject)this).DiscardItem();
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (((NetworkBehaviour)this).IsOwner && buttonDown && ((Behaviour)this).enabled && StartOfRound.Instance.shipHasLanded)
			{
				if (broken)
				{
					UseBrokenServerRpc();
				}
				else
				{
					ActivateBoosterServerRpc(activate: true);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ActivateBoosterServerRpc(bool activate)
		{
			//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_00dc: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3723853076u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref activate, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3723853076u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsServer && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			if (!broken)
			{
				if ((double)fuel <= 0.0)
				{
					activate = false;
				}
				ActivateBoosterClientRpc(activate);
			}
		}

		[ClientRpc]
		public void ActivateBoosterClientRpc(bool activate)
		{
			//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_00dc: 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_013d: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1457532584u, val, (RpcDelivery)0);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref activate, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1457532584u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				active = activate;
				base.playerHeldBy.disablingJetpackControls = !active;
				if (!active)
				{
					audioSource.Stop();
					return;
				}
				base.playerHeldBy.jetpackControls = true;
				base.playerHeldBy.syncFullRotation = ((Component)base.playerHeldBy).transform.eulerAngles;
				audioSource.PlayOneShot(Assets.JetPackThrustStart);
				audioSource.Play();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ExplodeBoosterServerRpc()
		{
			//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_00c1: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1032996413u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1032996413u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!broken && !((double)fuel <= 0.0))
				{
					ExplodeBoosterClientRpc();
				}
			}
		}

		[ClientRpc]
		public void ExplodeBoosterClientRpc()
		{
			//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_00c1: 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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1037012854u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1037012854u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					broken = true;
					fuel = 0f;
					audioSource.Stop();
					((GrabbableObject)this).SetScrapValue(base.scrapValue / 5);
					Landmine.SpawnExplosion(((Component)this).transform.position, true, 2f, 5f, 50, 5f, (GameObject)null, false);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void UseBrokenServerRpc()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(634672759u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 634672759u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					UseBrokenClientRpc();
				}
			}
		}

		[ClientRpc]
		public void UseBrokenClientRpc()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2266048005u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2266048005u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					audioSource.PlayOneShot(Assets.JetpackBroken);
				}
			}
		}

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

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3723853076u, new RpcReceiveHandler(__rpc_handler_3723853076), "ActivateBoosterServerRpc");
			((NetworkBehaviour)this).__registerRpc(1457532584u, new RpcReceiveHandler(__rpc_handler_1457532584), "ActivateBoosterClientRpc");
			((NetworkBehaviour)this).__registerRpc(1032996413u, new RpcReceiveHandler(__rpc_handler_1032996413), "ExplodeBoosterServerRpc");
			((NetworkBehaviour)this).__registerRpc(1037012854u, new RpcReceiveHandler(__rpc_handler_1037012854), "ExplodeBoosterClientRpc");
			((NetworkBehaviour)this).__registerRpc(634672759u, new RpcReceiveHandler(__rpc_handler_634672759), "UseBrokenServerRpc");
			((NetworkBehaviour)this).__registerRpc(2266048005u, new RpcReceiveHandler(__rpc_handler_2266048005), "UseBrokenClientRpc");
			((GrabbableObject)this).__initializeRpcs();
		}

		private static void __rpc_handler_3723853076(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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool activate = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref activate, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).ActivateBoosterServerRpc(activate);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1457532584(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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool activate = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref activate, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).ActivateBoosterClientRpc(activate);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1032996413(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).ExplodeBoosterServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1037012854(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).ExplodeBoosterClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_634672759(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).UseBrokenServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2266048005(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: 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)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((BoosterBehaviour)(object)target).UseBrokenClientRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		protected internal override string __getTypeName()
		{
			return "BoosterBehaviour";
		}
	}
	public class CasqueBehaviour : NoisemakerProp
	{
		private AudioSource itemAudio;

		private float lastTimeUsed;

		private AudioDistortionFilter distortionFilter;

		private float breakChance = 5f;

		public override void Start()
		{
			((NoisemakerProp)this).Start();
			itemAudio = ((Component)this).gameObject.GetComponent<AudioSource>();
			distortionFilter = ((Component)this).gameObject.AddComponent<AudioDistortionFilter>();
			distortionFilter.distortionLevel = 0.75f;
		}

		public override void ItemActivate(bool used, bool buttonDown = true)
		{
			if (!buttonDown || !((NetworkBehaviour)this).IsOwner || (double)(Time.time - lastTimeUsed) < 3.0 || ((GrabbableObject)this).deactivated)
			{
				return;
			}
			if (Random.Range(0f, 100f) <= breakChance && StartOfRound.Instance.shipHasLanded)
			{
				BreakServerRpc();
				if (!((Object)(object)((GrabbableObject)this).playerHeldBy == (Object)null))
				{
					ItemDropServerRpc(((GrabbableObject)this).playerHeldBy.playerClientId);
				}
			}
			else
			{
				lastTimeUsed = Time.time;
				PlayRandomSoundServerRpc();
			}
		}

		public override void Update()
		{
			((GrabbableObject)this).Update();
			((GrabbableObject)this).useCooldown = ((Time.time - lastTimeUsed >= 3f) ? 0f : 10f);
		}

		public override void GrabItem()
		{
			if (!((GrabbableObject)this).deactivated && ((NetworkBehaviour)this).IsOwner && Object.op_Implicit((Object)(object)((GrabbableObject)this).playerHeldBy))
			{
				ItemGrabServerRpc(((GrabbableObject)this).playerHeldBy.playerClientId);
			}
			distortionFilter.distortionLevel = 0.75f;
			((GrabbableObject)this).GrabItem();
		}

		public override void DiscardItem()
		{
			if (!((GrabbableObject)this).deactivated && ((NetworkBehaviour)this).IsOwner && Object.op_Implicit((Object)(object)((GrabbableObject)this).playerHeldBy))
			{
				ItemDropServerRpc(((GrabbableObject)this).playerHeldBy.playerClientId);
			}
			distortionFilter.distortionLevel = 0f;
			((GrabbableObject)this).DiscardItem();
		}

		public void PlaySoundLocal(int soundId)
		{
			itemAudio.PlayOneShot(Assets.KaquiteClips[soundId]);
		}

		private bool IsAnyCasqueInInventory(PlayerControllerB player, bool grab)
		{
			return player.ItemSlots.Any((GrabbableObject item) => (item is CasqueBehaviour && (Object)(object)item != (Object)(object)this) || grab);
		}

		public void ItemGrabLocal(ulong playerWhoGrabbed)
		{
			if (GameNetworkManager.Instance.localPlayerController.playerClientId == playerWhoGrabbed)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.playerClientId == playerWhoGrabbed)
				{
					SetPlayerDistortion(val, IsAnyCasqueInInventory(val, grab: true) ? 0.8f : 0f);
				}
			}
		}

		public void ItemDropLocal(ulong playerWhoDropped)
		{
			if (GameNetworkManager.Instance.localPlayerController.playerClientId == playerWhoDropped)
			{
				return;
			}
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.playerClientId == playerWhoDropped)
				{
					SetPlayerDistortion(val, IsAnyCasqueInInventory(val, grab: false) ? 0.8f : 0f);
				}
			}
		}

		private static void SetPlayerDistortion(PlayerControllerB player, float distortionLevel)
		{
			AudioDistortionFilter filterForPlayer = PlayerDistortionManager.GetFilterForPlayer(player);
			if (Object.op_Implicit((Object)(object)filterForPlayer))
			{
				filterForPlayer.distortionLevel = distortionLevel;
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void PlayRandomSoundServerRpc()
		{
			//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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3032412797u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3032412797u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				RoundManager.Instance.PlayAudibleNoise(((Component)this).transform.position, 25f, 0.9f, 0, false, 0);
				int soundId = Random.Range(0, Assets.KaquiteClips.Count);
				if (!((NetworkBehaviour)this).IsHost)
				{
					PlaySoundLocal(soundId);
				}
				PlaySoundClientRpc(soundId);
			}
		}

		[ClientRpc]
		public void PlaySoundClientRpc(int soundId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1612812337u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, soundId);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1612812337u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					PlaySoundLocal(soundId);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ItemGrabServerRpc(ulong playerWhoGrabbed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3726082168u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerWhoGrabbed);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3726082168u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsHost)
				{
					ItemGrabLocal(playerWhoGrabbed);
				}
				ItemGrabClientRpc(playerWhoGrabbed);
			}
		}

		[ClientRpc]
		public void ItemGrabClientRpc(ulong playerWhoGrabbed)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1583903099u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerWhoGrabbed);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1583903099u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ItemGrabLocal(playerWhoGrabbed);
				}
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void ItemDropServerRpc(ulong playerWhoDropped)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1507338783u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, playerWhoDropped);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1507338783u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				if (!((NetworkBehaviour)this).IsHost)
				{
					ItemDropLocal(playerWhoDropped);
				}
				ItemDropClientRpc(playerWhoDropped);
			}
		}

		[ClientRpc]
		public void ItemDropClientRpc(ulong playerWhoDropped)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_0071: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3140763079u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, playerWhoDropped);
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3140763079u, val, (RpcDelivery)0);
				}
				if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
					ItemDropLocal(playerWhoDropped);
				}
			}
		}

		private void SpawnItem(Item item, Vector3 deltaPos)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(item.spawnPrefab, ((Component)this).transform.position + deltaPos, Quaternion.identity);
			GrabbableObject component = val.GetComponent<GrabbableObject>();
			((Component)component).transform.rotation = Quaternion.Euler(component.itemProperties.restingRotation);
			component.fallTime = 0f;
			val.GetComponent<NetworkObject>().Spawn(false);
			component.FallToGround(true, true, default(Vector3));
			component.SetScrapValue(((GrabbableObject)this).scrapValue / 2);
		}

		[ServerRpc(RequireOwnership = false)]
		public void BreakServerRpc()
		{
			//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_00c1: 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_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0129: 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_0134: 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)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1848940189u, val, (RpcDelivery)0);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1848940189u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				Vector3 val3 = default(Vector3);
				((Vector3)(ref val3))..ctor(0.25f, 0f, 0f);
				if ((Object)(object)((GrabbableObject)this).playerHeldBy != (Object)null && !((GrabbableObject)this).playerHeldBy.isPlayerDead && ((GrabbableObject)this).playerHeldBy.isPlayerControlled)
				{
					val3 = ((Component)((GrabbableObject)this).playerHeldBy.gameplayCamera).transform.right;
					((Vector3)(ref val3)).Normalize();
					val3 *= 0.25f;
				}
				SpawnItem(Assets.LeftHeadsetItem, val3);
				SpawnItem(Assets.RightHeadsetItem, -val3);
				BreakClientRpc();
			}
		}

		[ClientRpc]
		public void BreakClientRpc()
		{
			//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 in