using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using PossessedMasks.NetcodePatcher;
using PossessedMasks.mono;
using PossessedMasks.networking;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.AI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("PossessedMasks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+879fe035f095123ebe4ec9395f13aa2e5db21493")]
[assembly: AssemblyProduct("PossessedMasks")]
[assembly: AssemblyTitle("PossessedMasks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PossessedMasks
{
	public static class ModConfig
	{
		internal static ConfigEntry<bool> EnableMaskPossessionMechanic;

		internal static ConfigEntry<bool> EnableMaskSwitchSlotMechanic;

		internal static ConfigEntry<int> EnableChangeMaskSpawnChance;

		internal static ConfigEntry<int> NumberOfSlotsFilledToEnableDroppingMask;

		internal static ConfigEntry<float> TimeToStartSwitchingSlots;

		internal static ConfigEntry<float> TimeToStartPossession;

		internal static ConfigEntry<bool> TwoHandedItemBehaviour;

		internal static ConfigEntry<int> MaskRarity;

		internal static ConfigEntry<bool> MaskRarityScaling;

		internal static ConfigEntry<float> MaskRarityScalingMultiplier;

		internal static ConfigEntry<int> MinMaskItemBaseValue;

		internal static ConfigEntry<int> MaxMaskItemBaseValue;

		internal static ConfigEntry<float> MinTimeToSwitchSlots;

		internal static ConfigEntry<float> MaxTimeToSwitchSlots;

		internal static ConfigEntry<float> DeltaTimeToSwitchSlots;

		internal static ConfigEntry<float> MinSwitchingSlotTime;

		internal static ConfigEntry<float> MinTimeToPossess;

		internal static ConfigEntry<float> MaxTimeToPossess;

		internal static ConfigEntry<float> DeltaTimeToPossess;

		internal static ConfigEntry<float> MinPossessingTime;

		internal static ConfigEntry<float> MinTimeToPossessPlayer;

		internal static ConfigEntry<float> MaxTimeToPossessPlayer;

		internal static ConfigEntry<float> DeltaTimeToPossessPlayer;

		internal static ConfigEntry<float> MaxPossessingPlayerTime;

		internal static bool Loaded { get; private set; }

		internal static void Init(ConfigFile config)
		{
			EnableMaskPossessionMechanic = config.Bind<bool>("Mechanics", "EnableMaskPossessionMechanic", true, "If true, mask possession mechanic will be enabled");
			EnableMaskSwitchSlotMechanic = config.Bind<bool>("Mechanics", "EnableMaskSwitchSlotMechanic", true, "If true, mask switching to your active slot mechanic will be enabled");
			EnableChangeMaskSpawnChance = config.Bind<int>("Mechanics", "EnableChangeMaskSpawnChance", 2, "If 0, will not override mask spawn chance, scrap value and available levels.\nIf 1, will override spawn chance, scrap value but not available levels.\nif 2 will override all of them.\nif 3 will override value but non of the other stuff");
			NumberOfSlotsFilledToEnableDroppingMask = config.Bind<int>("General", "NumberOfSlotsFilledToEnableDroppingMask", 3, "Number of inventory slots that need to be filled to enable dropping a mask");
			TimeToStartSwitchingSlots = config.Bind<float>("General", "TimeToStartSwitchingSlots", 5f, "After this much time with mask in inventory start switching slots");
			TimeToStartPossession = config.Bind<float>("General", "TimeToStartPossession", 10f, "After this much time with mask in inventory start possessions");
			TwoHandedItemBehaviour = config.Bind<bool>("General", "TwoHandedItemBehaviour", true, "If true, 2 handed items will be dropped when switching slots");
			MaskRarity = config.Bind<int>("Mask Rarity", "MaskRarity", 35, "Rarity of mask item 0 - 100 (0 - doesn't spawn, 100 - spawns a lot)");
			MaskRarityScaling = config.Bind<bool>("Mask Rarity", "MaskRarityScaling", true, "If true, mask rarity will be scaled up by moon rank");
			MaskRarityScalingMultiplier = config.Bind<float>("Mask Rarity", "MaskRarityScalingMultiplier", 0.5f, "Multiplier for mask rarity scaling");
			MinMaskItemBaseValue = config.Bind<int>("Mask Item Base Value", "MinMaskItemBaseValue", 100, "Minimum base value of mask item (affected by multipliers >1)");
			MaxMaskItemBaseValue = config.Bind<int>("Mask Item Base Value", "MaxMaskItemBaseValue", 150, "Maximum base value of mask item (affected by multipliers >1)");
			MinTimeToSwitchSlots = config.Bind<float>("Time To Switch Slots", "MinTimeToSwitchSlots", 12f, "Minimum time between switching slots");
			MaxTimeToSwitchSlots = config.Bind<float>("Time To Switch Slots", "MaxTimeToSwitchSlots", 20f, "Maximum time between switching slots");
			DeltaTimeToSwitchSlots = config.Bind<float>("Time To Switch Slots", "DeltaTimeToSwitchSlots", 0.5f, "Time to subtract from min and max each time a switch happens");
			MinSwitchingSlotTime = config.Bind<float>("Time To Switch Slots", "MinSwitchingSlotTime", 3f, "The number at which subtracting from min and max stops");
			MinTimeToPossess = config.Bind<float>("Time To Possess", "MinTimeToPossess", 20f, "Minimum time between possessions");
			MaxTimeToPossess = config.Bind<float>("Time To Possess", "MaxTimeToPossess", 30f, "Maximum time between possessions");
			DeltaTimeToPossess = config.Bind<float>("Time To Possess", "DeltaTimeToPossess", 1f, "Time to subtract from min and max each time a possession happens");
			MinPossessingTime = config.Bind<float>("Time To Possess", "MinPossessingTime", 10f, "The number at which subtracting from min and max stops");
			MinTimeToPossessPlayer = config.Bind<float>("Item Activation Time", "MinTimeToPossessPlayer", 2f, "Minimum time of actual possession");
			MaxTimeToPossessPlayer = config.Bind<float>("Item Activation Time", "MaxTimeToPossessPlayer", 4f, "Maximum time of actual possession");
			DeltaTimeToPossessPlayer = config.Bind<float>("Item Activation Time", "DeltaTimeToPossessPlayer", 1f, "Time to add to min and max each time a possession happens");
			MaxPossessingPlayerTime = config.Bind<float>("Item Activation Time", "MaxPossessingPlayerTime", 9f, "The number at which adding to min and max stops");
			Loaded = true;
		}
	}
	[BepInDependency("evaisa.lethallib", "0.14.1")]
	[BepInPlugin("oe.tweaks.qol.possessedmasks", "Possessed Masks", "2.0.4")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("oe.tweaks.qol.possessedmasks");

		public const string Guid = "oe.tweaks.qol.possessedmasks";

		internal const string Name = "Possessed Masks";

		public const string Version = "2.0.4";

		internal static Plugin Instance;

		internal static List<GameObject> NetworkPrefabs = new List<GameObject>();

		internal static ManualLogSource Log;

		private AssetBundle _ab;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"'Possessed Masks' is loading...");
			if (!Object.op_Implicit((Object)(object)Instance))
			{
				Instance = this;
			}
			ModConfig.Init(((BaseUnityPlugin)this).Config);
			_ab = AssetBundle.LoadFromStream(Assembly.GetExecutingAssembly().GetManifestResourceStream(Assembly.GetExecutingAssembly().GetManifestResourceNames()[0]));
			if (!Object.op_Implicit((Object)(object)_ab))
			{
				Log.LogError((object)"Failed to load asset bundle");
				return;
			}
			Log.LogInfo((object)"Asset bundle loaded");
			Utils.PossessionSounds.Add(_ab.LoadAsset<AudioClip>("possession1"));
			Utils.PossessionSounds.Add(_ab.LoadAsset<AudioClip>("possession2"));
			Utils.PossessionSounds.Add(_ab.LoadAsset<AudioClip>("possession3"));
			Utils.SlotSwitchSounds.Add(_ab.LoadAsset<AudioClip>("slot1"));
			Utils.SlotSwitchSounds.Add(_ab.LoadAsset<AudioClip>("slot2"));
			GameObject val = NetworkPrefabs.CreateNetworkPrefab("PossessedBehaviour");
			val.AddComponent<PossessedBehaviour>();
			NetworkPrefabs.Add(val);
			InitializeNetworkRoutine();
			harmony.PatchAll();
			Log.LogInfo((object)"'Possessed Masks' loaded!");
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		private void InitializeNetworkRoutine()
		{
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						try
						{
							methodInfo.Invoke(null, null);
						}
						catch (Exception arg)
						{
							Log.LogError((object)$"Failed to invoke method {methodInfo.Name}: {arg}");
						}
					}
				}
			}
		}
	}
	public static class SharedConfig
	{
		public static int ItemCount { get; set; }

		public static bool TwoHandedBehaviour { get; set; }

		internal static IEnumerator DelayedRequestConfig()
		{
			if (Utils.HostCheck)
			{
				yield return (object)new WaitUntil((Func<bool>)(() => ModConfig.Loaded));
				ItemCount = ModConfig.NumberOfSlotsFilledToEnableDroppingMask.Value;
				TwoHandedBehaviour = ModConfig.TwoHandedItemBehaviour.Value;
			}
			else
			{
				yield return (object)new WaitUntil((Func<bool>)(() => Object.op_Implicit((Object)(object)PossessedBehaviour.Instance)));
				PossessedBehaviour.Instance.RequestConfigServerRpc();
			}
		}
	}
	public static class Utils
	{
		public static Item TragedyItem;

		public static Item ComedyItem;

		public static Dictionary<Type, GameObject> EnemyPrefabRegistry = new Dictionary<Type, GameObject>();

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

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

		public static Terminal Terminal;

		private static bool _registered;

		public static List<GameObject> InsideAINodes;

		public static List<GameObject> OutsideAINodes;

		public static bool HostCheck => NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer;

		public static bool InLevel => Object.op_Implicit((Object)(object)StartOfRound.Instance) && !StartOfRound.Instance.inShipPhase && StartOfRound.Instance.currentLevelID != 3;

		private static void RegisterEnemyPrefab(Type enemyAI, GameObject prefab)
		{
			if (typeof(EnemyAI).IsAssignableFrom(enemyAI))
			{
				EnemyPrefabRegistry.TryAdd(enemyAI, prefab);
			}
		}

		private static void SetComedyAndTragedy()
		{
			ComedyItem = ((IEnumerable<Item>)StartOfRound.Instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item item) => item.itemName == "Comedy"));
			TragedyItem = ((IEnumerable<Item>)StartOfRound.Instance.allItemsList.itemsList).FirstOrDefault((Func<Item, bool>)((Item item) => item.itemName == "Tragedy"));
			if (!Object.op_Implicit((Object)(object)ComedyItem))
			{
				Plugin.Log.LogMessage((object)"Comedy item not found!");
			}
			else
			{
				Plugin.Log.LogMessage((object)"Comedy item found!");
				ComedyItem.minValue = ModConfig.MinMaskItemBaseValue.Value;
				ComedyItem.maxValue = ModConfig.MaxMaskItemBaseValue.Value;
			}
			if (!Object.op_Implicit((Object)(object)TragedyItem))
			{
				Plugin.Log.LogMessage((object)"Tragedy item not found!");
				return;
			}
			Plugin.Log.LogMessage((object)"Tragedy item found!");
			TragedyItem.minValue = ModConfig.MinMaskItemBaseValue.Value;
			TragedyItem.maxValue = ModConfig.MaxMaskItemBaseValue.Value;
		}

		private static void TweakSpawnChanceAndMoons()
		{
			SelectableLevel[] moonsCatalogueList = Terminal.moonsCatalogueList;
			float value = ModConfig.MaskRarityScalingMultiplier.Value;
			SelectableLevel[] array = moonsCatalogueList;
			foreach (SelectableLevel val in array)
			{
				int rarity2 = Mathf.Clamp(Mathf.RoundToInt((float)ModConfig.MaskRarity.Value + (ModConfig.MaskRarityScaling.Value ? (value * (float)val.maxTotalScrapValue / 100f) : 0f)), 0, 100);
				val.Enemies.ForEach(delegate(SpawnableEnemyWithRarity spawnable)
				{
					GameObject enemyPrefab = spawnable.enemyType.enemyPrefab;
					RegisterEnemyPrefab(((object)enemyPrefab.GetComponent<EnemyAI>()).GetType(), enemyPrefab);
				});
				if (ModConfig.EnableChangeMaskSpawnChance.Value != 0)
				{
					SetMoonSpawn(ComedyItem, rarity2, val);
					SetMoonSpawn(TragedyItem, rarity2, val);
				}
			}
			static void SetMoonSpawn(Item item, int rarity, SelectableLevel level)
			{
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: 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_003e: Expected O, but got Unknown
				if (Object.op_Implicit((Object)(object)item))
				{
					SpawnableItemWithRarity val2 = new SpawnableItemWithRarity
					{
						spawnableItem = item,
						rarity = rarity
					};
					int num = level.spawnableScrap.FindIndex((SpawnableItemWithRarity lvlItem) => lvlItem.spawnableItem.itemName == item.itemName);
					if (num != -1)
					{
						if (ModConfig.EnableChangeMaskSpawnChance.Value == 3)
						{
							level.spawnableScrap[num].spawnableItem = val2.spawnableItem;
						}
						else
						{
							level.spawnableScrap[num] = val2;
						}
					}
					else if (ModConfig.EnableChangeMaskSpawnChance.Value == 2)
					{
						level.spawnableScrap.Add(val2);
					}
				}
			}
		}

		public static void RegisterAll()
		{
			if (!_registered && Object.op_Implicit((Object)(object)Terminal) && Object.op_Implicit((Object)(object)StartOfRound.Instance))
			{
				_registered = true;
				Plugin.Log.LogMessage((object)"Registering all!");
				SetComedyAndTragedy();
				TweakSpawnChanceAndMoons();
			}
		}

		public static void PlayRandomAudioClipFromList(AudioSource source, List<AudioClip> clips, float volumeScale = 1f)
		{
			source.PlayOneShot(clips[Random.Range(0, clips.Count)], volumeScale);
		}

		public static int MathMod(int muduli, int modulus)
		{
			return (muduli % modulus + modulus) % modulus;
		}

		public static bool IsActivePlayer(PlayerControllerB player)
		{
			return Object.op_Implicit((Object)(object)player) && player.isPlayerControlled && !player.isPlayerDead;
		}

		public static int ItemCount(PlayerControllerB player)
		{
			return player.ItemSlots.Count((GrabbableObject item) => Object.op_Implicit((Object)(object)item));
		}

		public static List<PlayerControllerB> GetActivePlayers(bool inside)
		{
			return Object.op_Implicit((Object)(object)ServerManager.Instance) ? ServerManager.Instance.ActivePlayers.FindAll((PlayerControllerB player) => player.isInsideFactory == inside) : new List<PlayerControllerB>();
		}

		public static (bool, T) FindFarthestAwayThingFromPosition<T>(Vector3 position, List<T> things, Func<T, Vector3> getThingPosition)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!things.Any())
			{
				return (false, default(T));
			}
			T farthestAwayThing = default(T);
			float farthestAwayThingDistance = float.NegativeInfinity;
			bool found = false;
			things.ForEach(delegate(T thing)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				float num = Vector3.Distance(position, getThingPosition(thing));
				if (num > farthestAwayThingDistance)
				{
					farthestAwayThingDistance = num;
					farthestAwayThing = thing;
					found = true;
				}
			});
			return (found, farthestAwayThing);
		}

		public static (bool, T) FindClosestThingToPosition<T>(Vector3 position, List<T> things, Func<T, Vector3> getThingPosition)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (!things.Any())
			{
				return (false, default(T));
			}
			T closestThing = default(T);
			float closestThingDistance = float.PositiveInfinity;
			bool found = false;
			things.ForEach(delegate(T thing)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				float num = Vector3.Distance(position, getThingPosition(thing));
				if (num < closestThingDistance)
				{
					closestThingDistance = num;
					closestThing = thing;
					found = true;
				}
			});
			return (found, closestThing);
		}

		public static bool PathNotVisibleByPlayer(NavMeshPath path)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] corners = path.corners;
			for (int i = 1; i < corners.Length; i++)
			{
				if (Physics.Linecast(corners[i - 1], corners[i], 262144))
				{
					return false;
				}
			}
			return true;
		}
	}
}
namespace PossessedMasks.patches
{
	[HarmonyPatch(typeof(GameNetworkManager))]
	public class GameNetworkManagerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		[HarmonyPriority(0)]
		private static void StartPostfix(GameNetworkManager __instance)
		{
			Plugin.NetworkPrefabs.ForEach(delegate(GameObject prefab)
			{
				NetworkManager.Singleton.AddNetworkPrefab(prefab);
			});
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	public class PlayerControllerBPatch
	{
		[HarmonyPatch("Discard_performed")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Discard_performedPrefix(PlayerControllerB __instance)
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			GrabbableObject currentlyHeldObjectServer = localPlayerController.currentlyHeldObjectServer;
			if (Utils.InLevel)
			{
				HauntedMaskItem val = (HauntedMaskItem)(object)((currentlyHeldObjectServer is HauntedMaskItem) ? currentlyHeldObjectServer : null);
				if (val != null && val.maskIsHaunted && Utils.ItemCount(localPlayerController) < SharedConfig.ItemCount)
				{
					return false;
				}
			}
			return true;
		}

		[HarmonyPatch("Interact_performed")]
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		private static bool Interact_performedPrefix(PlayerControllerB __instance)
		{
			PlayerControllerB localPlayerController = StartOfRound.Instance.localPlayerController;
			GrabbableObject currentlyHeldObjectServer = localPlayerController.currentlyHeldObjectServer;
			if (Utils.InLevel)
			{
				HauntedMaskItem val = (HauntedMaskItem)(object)((currentlyHeldObjectServer is HauntedMaskItem) ? currentlyHeldObjectServer : null);
				if (val != null && val.maskIsHaunted && (localPlayerController.activatingItem || Utils.ItemCount(localPlayerController) < SharedConfig.ItemCount))
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	public class RoundManagerPatch
	{
		[HarmonyPatch("FinishGeneratingLevel")]
		[HarmonyPostfix]
		private static void FinishGeneratingLevelPostfix(RoundManager __instance)
		{
			Utils.InsideAINodes = __instance.insideAINodes.ToList();
			Utils.OutsideAINodes = __instance.outsideAINodes.ToList();
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class StartOfRoundPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			if (Utils.HostCheck)
			{
				Plugin.Log.LogMessage((object)"Spawning network prefabs (host only)");
				Plugin.NetworkPrefabs.ForEach(delegate(GameObject prefab)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					Object.Instantiate<GameObject>(prefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>().Spawn(false);
				});
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(StartOfRound __instance)
		{
			if (Utils.HostCheck)
			{
				Plugin.Log.LogMessage((object)"Starting manager (host only)");
				((Component)__instance).gameObject.AddComponent<ServerManager>();
				Utils.RegisterAll();
			}
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	public class TerminalPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(Terminal __instance)
		{
			Utils.Terminal = __instance;
			if (Utils.HostCheck)
			{
				Utils.RegisterAll();
			}
		}
	}
}
namespace PossessedMasks.networking
{
	public class PossessedBehaviour : NetworkBehaviour
	{
		public static PossessedBehaviour Instance { get; private set; }

		private static bool IsMyPlayer(ulong ownerId)
		{
			Plugin.Log.LogDebug((object)$"Local Owner ID: {((NetworkBehaviour)StartOfRound.Instance.localPlayerController).OwnerClientId}, Owner ID: {ownerId}");
			return Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController) && ((NetworkBehaviour)StartOfRound.Instance.localPlayerController).OwnerClientId == ownerId;
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			Instance = this;
			((MonoBehaviour)this).StartCoroutine(SharedConfig.DelayedRequestConfig());
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			Instance = null;
		}

		[ServerRpc(RequireOwnership = false)]
		public void RequestConfigServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1017191677u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1017191677u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost) && Utils.HostCheck)
				{
					((MonoBehaviour)this).StartCoroutine(DelayedSendConfig());
				}
			}
		}

		private IEnumerator DelayedSendConfig()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => ModConfig.Loaded));
			SendConfigClientRpc(ModConfig.NumberOfSlotsFilledToEnableDroppingMask.Value, ModConfig.TwoHandedItemBehaviour.Value);
		}

		[ClientRpc]
		private void SendConfigClientRpc(int itemCount, bool twoHandedBehaviour)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3950309743u, val, (RpcDelivery)0);
					BytePacker.WriteValueBitPacked(val2, itemCount);
					((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref twoHandedBehaviour, default(ForPrimitives));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3950309743u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost) && !Utils.HostCheck)
				{
					SharedConfig.ItemCount = itemCount;
					SharedConfig.TwoHandedBehaviour = twoHandedBehaviour;
				}
			}
		}

		[ServerRpc]
		public void StartPossessionServerRpc(ulong ownerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1097494237u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1097494237u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				StartPossessionClientRpc(ownerId);
			}
		}

		[ClientRpc]
		private void StartPossessionClientRpc(ulong ownerId)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3265900518u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3265900518u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			if (IsMyPlayer(ownerId))
			{
				if (!Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer))
				{
					return;
				}
				GrabbableObject currentlyHeldObjectServer = StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer;
				HauntedMaskItem val3 = (HauntedMaskItem)(object)((currentlyHeldObjectServer is HauntedMaskItem) ? currentlyHeldObjectServer : null);
				if (val3 != null)
				{
					if ((double)Random.Range(0f, 1f) >= 0.33)
					{
						Utils.PlayRandomAudioClipFromList(val3.maskAudio, Utils.PossessionSounds);
					}
					((GrabbableObject)val3).ActivateItemServerRpc(true, true);
					((GrabbableObject)val3).ItemActivate(true, true);
				}
			}
			else
			{
				Plugin.Log.LogDebug((object)"StartPossessionClientRPC: not owner");
			}
		}

		[ServerRpc]
		public void StopPossessionServerRpc(ulong ownerId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3653823995u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3653823995u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				StopPossessionClientRpc(ownerId);
			}
		}

		[ClientRpc]
		private void StopPossessionClientRpc(ulong ownerId)
		{
			//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)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(2606043065u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 2606043065u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 2 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			if (IsMyPlayer(ownerId))
			{
				if (Object.op_Implicit((Object)(object)StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer))
				{
					GrabbableObject currentlyHeldObjectServer = StartOfRound.Instance.localPlayerController.currentlyHeldObjectServer;
					HauntedMaskItem val3 = (HauntedMaskItem)(object)((currentlyHeldObjectServer is HauntedMaskItem) ? currentlyHeldObjectServer : null);
					if (val3 != null)
					{
						((GrabbableObject)val3).ActivateItemServerRpc(false, false);
						((GrabbableObject)val3).ItemActivate(false, false);
					}
				}
			}
			else
			{
				Plugin.Log.LogDebug((object)"DeactivateMaskClientRPC: not owner");
			}
		}

		[ServerRpc]
		public void SwitchSlotServerRpc(ulong ownerId, bool forward, int maskSlot)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Invalid comparison between Unknown and I4
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(3141266536u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref forward, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, maskSlot);
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 3141266536u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				SwitchSlotClientRpc(ownerId, forward, maskSlot);
			}
		}

		[ClientRpc]
		private void SwitchSlotClientRpc(ulong ownerId, bool forward, int maskSlot)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 2 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1217869235u, val, (RpcDelivery)0);
				BytePacker.WriteValueBitPacked(val2, ownerId);
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref forward, default(ForPrimitives));
				BytePacker.WriteValueBitPacked(val2, maskSlot);
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1217869235u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 2 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (IsMyPlayer(ownerId))
				{
					((MonoBehaviour)this).StartCoroutine(DelayedSlotSwitch(forward, maskSlot));
				}
				else
				{
					Plugin.Log.LogDebug((object)"SwitchSlotClientRPC: not owner");
				}
			}
		}

		private IEnumerator DelayedSlotSwitch(bool forward, int maskSlot)
		{
			PlayerControllerB localPlayer = StartOfRound.Instance.localPlayerController;
			GrabbableObject potentialMask = localPlayer.ItemSlots[maskSlot];
			if ((double)Random.Range(0f, 1f) >= 0.33)
			{
				HauntedMaskItem mask = default(HauntedMaskItem);
				int num;
				if (Object.op_Implicit((Object)(object)potentialMask))
				{
					mask = (HauntedMaskItem)(object)((potentialMask is HauntedMaskItem) ? potentialMask : null);
					num = ((mask != null) ? 1 : 0);
				}
				else
				{
					num = 0;
				}
				if (num != 0)
				{
					Utils.PlayRandomAudioClipFromList(mask.maskAudio, Utils.SlotSwitchSounds);
				}
			}
			localPlayer.playerActions.FindAction("ActivateItem", false).Disable();
			localPlayer.playerActions.FindAction("SwitchItem", false).Disable();
			GrabbableObject currentHeld = localPlayer.ItemSlots[localPlayer.currentItemSlot];
			if (Object.op_Implicit((Object)(object)currentHeld) && (currentHeld.isBeingUsed || localPlayer.activatingItem))
			{
				currentHeld.UseItemOnClient(false);
				yield return (object)new WaitForEndOfFrame();
			}
			if (SharedConfig.TwoHandedBehaviour && localPlayer.twoHanded)
			{
				GrabbableObject heldObject = localPlayer.currentlyHeldObject;
				yield return ((MonoBehaviour)this).StartCoroutine(localPlayer.waitToEndOfFrameToDiscard());
				yield return (object)new WaitForEndOfFrame();
				heldObject.EnableItemMeshes(true);
			}
			localPlayer.SwitchToItemSlot(localPlayer.NextItemSlot(forward), (GrabbableObject)null);
			localPlayer.SwitchItemSlotsServerRpc(forward);
			localPlayer.playerActions.FindAction("ActivateItem", false).Enable();
			localPlayer.playerActions.FindAction("SwitchItem", false).Enable();
		}

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

		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeRPCS_PossessedBehaviour()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			NetworkManager.__rpc_func_table.Add(1017191677u, new RpcReceiveHandler(__rpc_handler_1017191677));
			NetworkManager.__rpc_func_table.Add(3950309743u, new RpcReceiveHandler(__rpc_handler_3950309743));
			NetworkManager.__rpc_func_table.Add(1097494237u, new RpcReceiveHandler(__rpc_handler_1097494237));
			NetworkManager.__rpc_func_table.Add(3265900518u, new RpcReceiveHandler(__rpc_handler_3265900518));
			NetworkManager.__rpc_func_table.Add(3653823995u, new RpcReceiveHandler(__rpc_handler_3653823995));
			NetworkManager.__rpc_func_table.Add(2606043065u, new RpcReceiveHandler(__rpc_handler_2606043065));
			NetworkManager.__rpc_func_table.Add(3141266536u, new RpcReceiveHandler(__rpc_handler_3141266536));
			NetworkManager.__rpc_func_table.Add(1217869235u, new RpcReceiveHandler(__rpc_handler_1217869235));
		}

		private static void __rpc_handler_1017191677(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;
				((PossessedBehaviour)(object)target).RequestConfigServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3950309743(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				int itemCount = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref itemCount);
				bool twoHandedBehaviour = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref twoHandedBehaviour, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PossessedBehaviour)(object)target).SendConfigClientRpc(itemCount, twoHandedBehaviour);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1097494237(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				ulong ownerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PossessedBehaviour)(object)target).StartPossessionServerRpc(ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3265900518(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)
			{
				ulong ownerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PossessedBehaviour)(object)target).StartPossessionClientRpc(ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3653823995(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
			}
			else
			{
				ulong ownerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((PossessedBehaviour)(object)target).StopPossessionServerRpc(ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2606043065(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)
			{
				ulong ownerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PossessedBehaviour)(object)target).StopPossessionClientRpc(ownerId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3141266536(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			ulong ownerId = default(ulong);
			ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
			bool forward = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref forward, default(ForPrimitives));
			int maskSlot = default(int);
			ByteUnpacker.ReadValueBitPacked(reader, ref maskSlot);
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((PossessedBehaviour)(object)target).SwitchSlotServerRpc(ownerId, forward, maskSlot);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_1217869235(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				ulong ownerId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref ownerId);
				bool forward = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref forward, default(ForPrimitives));
				int maskSlot = default(int);
				ByteUnpacker.ReadValueBitPacked(reader, ref maskSlot);
				target.__rpc_exec_stage = (__RpcExecStage)2;
				((PossessedBehaviour)(object)target).SwitchSlotClientRpc(ownerId, forward, maskSlot);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "PossessedBehaviour";
		}
	}
}
namespace PossessedMasks.mono
{
	public class ServerManager : MonoBehaviour
	{
		private class PlayerProps
		{
			public float TimeUntilSlotSwitch = Random.Range(ModConfig.MinTimeToSwitchSlots.Value, ModConfig.MaxTimeToSwitchSlots.Value) + ModConfig.TimeToStartSwitchingSlots.Value;

			private float _timeUntilSlotSwitchDelta = 0f;

			public bool Possessing = false;

			public float TimeUntilPossession = Random.Range(ModConfig.MinTimeToPossess.Value, ModConfig.MaxTimeToPossess.Value) + ModConfig.TimeToStartPossession.Value;

			private float _timeUntilPossessionDelta = 0f;

			public float TimeUntilUnpossession = 0f;

			private float _timeUntilUnpossessionDelta = 0f;

			public void GenerateTimeUntilSlotSwitch()
			{
				_timeUntilSlotSwitchDelta += ModConfig.DeltaTimeToSwitchSlots.Value;
				TimeUntilSlotSwitch = Mathf.Clamp(Random.Range(ModConfig.MinTimeToSwitchSlots.Value - _timeUntilSlotSwitchDelta, ModConfig.MaxTimeToSwitchSlots.Value - _timeUntilSlotSwitchDelta), ModConfig.MinSwitchingSlotTime.Value, float.MaxValue);
			}

			public void GenerateTimeUntilPossession()
			{
				_timeUntilPossessionDelta += ModConfig.DeltaTimeToPossess.Value;
				TimeUntilPossession = Mathf.Clamp(Random.Range(ModConfig.MinTimeToPossess.Value - _timeUntilPossessionDelta, ModConfig.MaxTimeToPossess.Value - _timeUntilPossessionDelta), ModConfig.MinPossessingTime.Value, float.MaxValue);
			}

			public void GenerateTimeUntilUnpossession()
			{
				_timeUntilUnpossessionDelta += ModConfig.DeltaTimeToPossessPlayer.Value;
				TimeUntilUnpossession = Mathf.Clamp(Random.Range(ModConfig.MinTimeToPossessPlayer.Value + _timeUntilUnpossessionDelta, ModConfig.MaxTimeToPossessPlayer.Value + _timeUntilUnpossessionDelta), float.MinValue, ModConfig.MaxPossessingPlayerTime.Value);
			}
		}

		internal static ServerManager Instance;

		private int _currIndex;

		private bool _usingData = false;

		private readonly Dictionary<PlayerControllerB, PlayerProps> _playerProps = new Dictionary<PlayerControllerB, PlayerProps>();

		internal readonly List<PlayerControllerB> ActivePlayers = new List<PlayerControllerB>();

		private float _avgFrameTime;

		private bool ShouldUpdate => Utils.InLevel && ActivePlayers.Count > 0;

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(WaitUntilAllowed());
			Instance = this;
		}

		private void Update()
		{
			_avgFrameTime = (_avgFrameTime + Time.deltaTime) / 2f;
			if (!ShouldUpdate)
			{
				if (ActivePlayers.Count != 0 || _currIndex != 0)
				{
					ActivePlayers.Clear();
					_currIndex = 0;
				}
				return;
			}
			PlayerControllerB val = ActivePlayers[_currIndex];
			if (!_usingData && Utils.IsActivePlayer(val))
			{
				_usingData = true;
				DoInterval(val);
				_usingData = false;
				_currIndex = (_currIndex + 1) % ActivePlayers.Count;
			}
			else
			{
				ActivePlayers.Remove(val);
				_currIndex = 0;
			}
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		private void DoInterval(PlayerControllerB player)
		{
			var (num, forward) = FindClosestMask(player);
			if (num != -1 && _playerProps.TryGetValue(player, out var value))
			{
				float num2 = _avgFrameTime * (float)ActivePlayers.Count;
				if (ModConfig.EnableMaskSwitchSlotMechanic.Value)
				{
					value.TimeUntilSlotSwitch -= num2;
				}
				if (ModConfig.EnableMaskPossessionMechanic.Value)
				{
					value.TimeUntilPossession -= num2;
					value.TimeUntilUnpossession -= num2;
				}
				if (value != null && value.Possessing && value.TimeUntilUnpossession <= 0f)
				{
					value.GenerateTimeUntilPossession();
					value.GenerateTimeUntilSlotSwitch();
					PossessedBehaviour.Instance.StopPossessionServerRpc(((NetworkBehaviour)player).OwnerClientId);
					value.Possessing = false;
				}
				else if (num == player.currentItemSlot && value != null && !value.Possessing && value.TimeUntilPossession <= 0f)
				{
					value.GenerateTimeUntilUnpossession();
					PossessedBehaviour.Instance.StartPossessionServerRpc(((NetworkBehaviour)player).OwnerClientId);
					value.Possessing = true;
				}
				else if (num != player.currentItemSlot && value != null && !value.Possessing && value.TimeUntilSlotSwitch <= 0f)
				{
					value.GenerateTimeUntilSlotSwitch();
					PossessedBehaviour.Instance.SwitchSlotServerRpc(((NetworkBehaviour)player).OwnerClientId, forward, num);
				}
			}
		}

		private IEnumerator NewLevel()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => !_usingData));
			_usingData = true;
			ActivePlayers.Clear();
			_playerProps.Clear();
			ActivePlayers.AddRange(StartOfRound.Instance.allPlayerScripts.Where(Utils.IsActivePlayer));
			ActivePlayers.ForEach(delegate(PlayerControllerB player)
			{
				_playerProps[player] = new PlayerProps();
			});
			_usingData = false;
		}

		private IEnumerator WaitUntilAllowed()
		{
			yield return (object)new WaitUntil((Func<bool>)(() => Utils.InLevel));
			yield return (object)new WaitForEndOfFrame();
			((MonoBehaviour)this).StartCoroutine(NewLevel());
			yield return (object)new WaitUntil((Func<bool>)(() => !Utils.InLevel));
			yield return (object)new WaitForEndOfFrame();
			((MonoBehaviour)this).StartCoroutine(WaitUntilAllowed());
		}

		private static (int, bool) FindClosestMask(PlayerControllerB player)
		{
			int currentItemSlot = player.currentItemSlot;
			int num = player.ItemSlots.Length;
			for (int i = 0; i <= num / 2; i++)
			{
				int num2 = Utils.MathMod(currentItemSlot + i, num);
				if (Object.op_Implicit((Object)(object)player.ItemSlots[num2]))
				{
					GrabbableObject obj = player.ItemSlots[num2];
					HauntedMaskItem val = (HauntedMaskItem)(object)((obj is HauntedMaskItem) ? obj : null);
					if (val != null && val.maskIsHaunted)
					{
						return (num2, true);
					}
				}
				num2 = Utils.MathMod(currentItemSlot - i, num);
				if (Object.op_Implicit((Object)(object)player.ItemSlots[num2]))
				{
					GrabbableObject obj2 = player.ItemSlots[num2];
					HauntedMaskItem val = (HauntedMaskItem)(object)((obj2 is HauntedMaskItem) ? obj2 : null);
					if (val != null && val.maskIsHaunted)
					{
						return (num2, false);
					}
				}
			}
			return (-1, false);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace PossessedMasks.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}