#define DEBUG
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.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using Backrooms;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using GameNetcodeStuff;
using GroanTubeScrap;
using HarmonyLib;
using JetBrains.Annotations;
using LCSoundTool;
using LethalLib.Modules;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Networking;

[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: AssemblyCompany("TestAccount666.RealBackroomsPatch")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Backrooms Patch, but real")]
[assembly: AssemblyFileVersion("1.4.0.0")]
[assembly: AssemblyInformationalVersion("1.4.0")]
[assembly: AssemblyProduct("RealBackroomsPatch")]
[assembly: AssemblyTitle("TestAccount666.RealBackroomsPatch")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.4.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RealBackroomsPatch
{
	public class BackroomsConfig
	{
		private readonly ConfigFile _configFile;

		public ConfigEntry<DropHeldItemsMode> DropHeldItemsMode { get; private set; }

		public ConfigEntry<bool> ShouldPreventDamageTeleport { get; private set; }

		public ConfigEntry<bool> ShouldPreventDeathTeleport { get; private set; }

		public ConfigEntry<bool> ShouldPreventNegativeDamageTeleport { get; private set; }

		[CanBeNull]
		public ConfigEntry<bool> ShouldSpawnDeadBody { get; private set; } = null;


		public ConfigEntry<bool> ShouldTeleportAnnoyingPeople { get; private set; }

		[CanBeNull]
		public ConfigEntry<bool> ShouldTeleportToAndReplaceDeadBody { get; private set; } = null;


		public ConfigEntry<int> TeleportAnnoyingPeopleChance { get; private set; }

		public ConfigEntry<int> TeleportLethalDamageChance { get; private set; }

		public ConfigEntry<int> TeleportNonLethalDamageChance { get; private set; }

		public ConfigEntry<string> PreventBackroomsTeleportEnemies { get; private set; }

		public ConfigEntry<int> LightFlickerSmoothing { get; private set; }

		public ConfigEntry<float> LightFlickerMinIntensity { get; private set; }

		public ConfigEntry<float> LightFlickerMaxIntensity { get; private set; }

		public ConfigEntry<bool> PlayMusic { get; private set; }

		public BackroomsConfig(string guid, ConfigFile configFile)
		{
			_configFile = configFile;
			HandleConfig();
			RemoveOrphans();
			Plugin.InfoLog("Printing Config:");
			Plugin.InfoLog($"DropHeldItemsMode: {DropHeldItemsMode.Value}");
			Plugin.InfoLog($"ShouldPreventDamageTeleport: {ShouldPreventDamageTeleport.Value}");
			Plugin.InfoLog($"ShouldPreventDeathTeleport: {ShouldPreventDeathTeleport.Value}");
			Plugin.InfoLog($"ShouldPreventNegativeDamageTeleport: {ShouldPreventNegativeDamageTeleport.Value}");
			Plugin.InfoLog($"ShouldTeleportAnnoyingPeople: {ShouldTeleportAnnoyingPeople.Value}");
			Plugin.InfoLog($"TeleportAnnoyingPeopleChance: {TeleportAnnoyingPeopleChance.Value}");
			Plugin.InfoLog($"TeleportLethalDamageChance: {TeleportLethalDamageChance.Value}");
			Plugin.InfoLog($"TeleportNonLethalDamageChance: {TeleportNonLethalDamageChance.Value}");
			Plugin.InfoLog("PreventBackroomsTeleportEnemies: " + PreventBackroomsTeleportEnemies.Value);
		}

		private void HandleConfig()
		{
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Expected O, but got Unknown
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			Plugin.InfoLog("Handling Config!");
			ShouldPreventDamageTeleport = _configFile.Bind<bool>("Teleport", "Prevent damage teleport", true, "If true, will prevent the backrooms mod from teleporting players that received damage");
			ShouldPreventDeathTeleport = _configFile.Bind<bool>("Teleport", "Prevent death teleport", false, "If true, will prevent the backrooms mod from teleporting players that received deadly damage");
			ShouldPreventNegativeDamageTeleport = _configFile.Bind<bool>("Teleport", "Prevent negative damage teleport", false, "If true, will prevent the backrooms mod from teleporting players that received negative damage (Aka healing)");
			DropHeldItemsMode = _configFile.Bind<DropHeldItemsMode>("Teleport", "Drop held items on teleport", RealBackroomsPatch.DropHeldItemsMode.DropNothing, "When do you want items to be dropped when teleported into the backrooms?");
			PreventBackroomsTeleportEnemies = _configFile.Bind<string>("Teleport", "Prevent backrooms when attacked by enemies", "Flowerman, MaskedPlayer", "A list of enemies that will not allow you to spawn in the backrooms, if attacked by them (Needs internal name. Example: Flowerman, Jester, ...)");
			TeleportLethalDamageChance = _configFile.Bind<int>("Chances", "Teleport lethal damage chance", 1, "The chance that a person will get teleported into the backrooms with lethal damage (Requires \"Prevent death teleport\" set to \"false\")");
			TeleportNonLethalDamageChance = _configFile.Bind<int>("Chances", "Teleport non-lethal damage chance", 3, "The chance that a person will get teleported into the backrooms with non-lethal damage (Requires \"Prevent damage teleport\" set to \"false\")");
			ShouldTeleportAnnoyingPeople = _configFile.Bind<bool>("Extra", "Teleport annoying people", false, "If true, will teleport annoying people (e.g. People using horns)");
			TeleportAnnoyingPeopleChance = _configFile.Bind<int>("Extra", "Teleport annoying people chance", 10, "The chance that annoying people can get teleported");
			LightFlickerSmoothing = _configFile.Bind<int>("Light Flickering", "Smoothing", 25, new ConfigDescription("How much to smooth out the randomness; lower values = sparks, higher = lantern", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			LightFlickerMinIntensity = _configFile.Bind<float>("Light Flickering", "Min intensity", 0.2f, new ConfigDescription("Minimum random light intensity", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			LightFlickerMaxIntensity = _configFile.Bind<float>("Light Flickering", "Max intensity", 1.5f, new ConfigDescription("Maximum random light intensity", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 2f), Array.Empty<object>()));
			PlayMusic = _configFile.Bind<bool>("Music", "Play Music", true, "If true, plays music in the backrooms");
			Plugin.InfoLog("Handled Config!");
		}

		private void RemoveOrphans()
		{
			PropertyInfo property = ((object)_configFile).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			if (!(property == null))
			{
				Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(_configFile, null);
				dictionary.Clear();
				_configFile.Save();
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public class DebugPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void PrintConfigOnStart()
		{
			Plugin.InfoLog("Printing Config:");
			Plugin.InfoLog($"DropHeldItemsMode: {Plugin.backroomsConfig.DropHeldItemsMode.Value}");
			Plugin.InfoLog($"ShouldPreventDamageTeleport: {Plugin.backroomsConfig.ShouldPreventDamageTeleport.Value}");
			Plugin.InfoLog($"ShouldPreventDeathTeleport: {Plugin.backroomsConfig.ShouldPreventDeathTeleport.Value}");
			Plugin.InfoLog($"ShouldPreventNegativeDamageTeleport: {Plugin.backroomsConfig.ShouldPreventNegativeDamageTeleport.Value}");
			Plugin.InfoLog($"ShouldTeleportAnnoyingPeople: {Plugin.backroomsConfig.ShouldTeleportAnnoyingPeople.Value}");
			Plugin.InfoLog($"TeleportAnnoyingPeopleChance: {Plugin.backroomsConfig.TeleportAnnoyingPeopleChance.Value}");
			Plugin.InfoLog($"TeleportLethalDamageChance: {Plugin.backroomsConfig.TeleportLethalDamageChance.Value}");
			Plugin.InfoLog($"TeleportNonLethalDamageChance: {Plugin.backroomsConfig.TeleportNonLethalDamageChance.Value}");
			Plugin.InfoLog("PreventBackroomsTeleportEnemies: " + Plugin.backroomsConfig.PreventBackroomsTeleportEnemies.Value);
		}
	}
	public static class DependencyChecker
	{
		public static bool IsGroanTubeModInstalled()
		{
			return Chainloader.PluginInfos.Values.Any((PluginInfo metadata) => metadata.Metadata.GUID.Equals("Kittenji.GroanTubeScrap"));
		}

		public static bool IsSoundToolsModInstalled()
		{
			return Chainloader.PluginInfos.Values.Any((PluginInfo metadata) => metadata.Metadata.GUID.Equals("LCSoundTool"));
		}
	}
	[DataContract]
	public enum DropHeldItemsMode
	{
		[EnumMember]
		DropNothing,
		[EnumMember]
		DropAll,
		[EnumMember]
		DropAllOnDeath,
		[EnumMember]
		DropAllOnAnnoying,
		[EnumMember]
		DropAllOnAnnoyingAndDeath
	}
	[HarmonyPatch]
	public class GroanTubePatch
	{
		public static MethodBase TargetMethod()
		{
			Type type2 = AccessTools.GetTypesFromAssembly(typeof(Loader).Assembly).FirstOrDefault((Type type1) => type1.Name.Contains("GroanTubeItem"));
			return (type2 == null) ? null : AccessTools.FirstMethod(type2, (Func<MethodInfo, bool>)((MethodInfo method) => method.Name.Contains("ItemActivate")));
		}

		public static void Prefix(NoisemakerProp __instance)
		{
			if (!((GrabbableObject)__instance).isHeld)
			{
				Plugin.WarningLog("Groan Tube not held!");
			}
			else
			{
				Patches.TeleportForAnnoyingPeople(((GrabbableObject)__instance).playerHeldBy);
			}
		}
	}
	[RequireComponent(typeof(SphereCollider))]
	public class FixedKillBox : MonoBehaviour
	{
		public void OnTriggerEnter(Collider other)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
			if (!((Object)(object)component == (Object)null))
			{
				component.KillPlayer(Vector3.zero, true, (CauseOfDeath)0, 0, default(Vector3));
			}
		}
	}
	[HarmonyPatch(typeof(LightFlickerEffect))]
	public static class LightFlickerEffectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		private static void StartPostfix(LightFlickerEffect __instance)
		{
			__instance.smoothing = Plugin.backroomsConfig.LightFlickerSmoothing.Value;
			__instance.minIntensity = Plugin.backroomsConfig.LightFlickerMinIntensity.Value;
			__instance.maxIntensity = Plugin.backroomsConfig.LightFlickerMaxIntensity.Value;
		}
	}
	public class MusicPlayer : MonoBehaviour
	{
		private const int MUSIC_COOLDOWN = 1000;

		private const float VOLUME_DECREASE_STEP = 0.05f;

		private readonly Random _random = new Random();

		[CanBeNull]
		private AudioSource _audioSource;

		private int? _instanceId;

		private long _nextTimePlaying = UnixTime.GetCurrentTime() + 1000;

		private bool _shouldStop;

		private void Update()
		{
			if (_shouldStop)
			{
				return;
			}
			long currentTime = UnixTime.GetCurrentTime();
			if (_nextTimePlaying <= currentTime)
			{
				int? instanceId = _instanceId;
				if (!instanceId.HasValue || Object.FindObjectFromInstanceID(_instanceId.Value) == null)
				{
					PlayMusic();
				}
			}
		}

		private void PlayMusic()
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			long currentTime = UnixTime.GetCurrentTime();
			int num = _random.Next(0, Plugin.MusicSounds.Count);
			AudioClip val = Plugin.MusicSounds[num];
			Plugin.DebugLog($"Playing clip '{((Object)val).name}' ({num})");
			GameObject val2 = new GameObject("TemporaryMusicAudio");
			_instanceId = ((Object)val2).GetInstanceID();
			_audioSource = val2.AddComponent<AudioSource>();
			Debug.Assert((Object)(object)_audioSource != (Object)null, "_audioSource != null");
			_audioSource.clip = val;
			_audioSource.volume = 0.5f;
			_audioSource.Play();
			_nextTimePlaying = (long)((float)(currentTime + 1000) + val.length * 1000f);
			Object.Destroy((Object)(object)val2, val.length);
		}

		public void Stop()
		{
			_shouldStop = true;
			((MonoBehaviour)this).StartCoroutine(FadeOutMusic());
		}

		private void TerminateMusic()
		{
			if (_instanceId.HasValue)
			{
				Object val = Object.FindObjectFromInstanceID(_instanceId.Value);
				if (val == (Object)null)
				{
					return;
				}
				Object.Destroy(val);
			}
			Object.Destroy((Object)(object)this);
		}

		private IEnumerator FadeOutMusic()
		{
			if ((Object)(object)_audioSource == (Object)null)
			{
				TerminateMusic();
				yield break;
			}
			if (!_audioSource.isPlaying)
			{
				TerminateMusic();
				yield break;
			}
			AudioSource audioSource = _audioSource;
			audioSource.volume -= 0.05f * Time.deltaTime;
			if (_audioSource.volume <= 0f)
			{
				TerminateMusic();
				yield break;
			}
			yield return (object)new WaitForEndOfFrame();
			yield return FadeOutMusic();
		}
	}
	[HarmonyPatch]
	public static class Patches
	{
		private static readonly List<ulong> _ImmortalPlayers = new List<ulong>();

		private static readonly int _BiohazardDamage = Animator.StringToHash("biohazardDamage");

		public static void UnpatchDamagePlayerMethod([NotNull] Harmony harmony)
		{
			if (!Unpatch<PlayerControllerB>(harmony, "DamagePlayer", "BeforeDamage"))
			{
				Plugin.ErrorLog("Failed to unpatch DamagePlayer!");
			}
		}

		public static void UnpatchKillPlayerMethod([NotNull] Harmony harmony)
		{
			if (!Unpatch<KillLocalPlayer>(harmony, "KillPlayer", "BeforeKilling"))
			{
				Plugin.ErrorLog("Failed to unpatch KillPlayer!");
			}
		}

		[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
		[HarmonyPrefix]
		public static bool TeleportOnDamage(int damageNumber, CauseOfDeath causeOfDeath, Vector3 force, int deathAnimation, PlayerControllerB __instance)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			bool lethalDamage = __instance.health - damageNumber <= 0;
			bool negativeDamage = damageNumber <= 0;
			Plugin.InfoLog("TeleportOnDamage!");
			if (!MeetRequirementsForBackrooms(__instance, lethalDamage, negativeDamage))
			{
				return true;
			}
			RpcCollection.Instance.TeleportPlayerToBackroomsServerRpc((int)__instance.playerClientId, spawnBody: false, force, causeOfDeath, deathAnimation, lethalDamage, negativeDamage);
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
		[HarmonyPrefix]
		public static bool TeleportOnKill(Vector3 bodyVelocity, bool spawnBody, CauseOfDeath causeOfDeath, int deathAnimation, Vector3 positionOffset, PlayerControllerB __instance)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Plugin.InfoLog("TeleportOnKill!");
			if (Plugin.backroomsConfig.ShouldPreventDeathTeleport.Value)
			{
				return true;
			}
			if (!MeetRequirementsForBackrooms(__instance))
			{
				return true;
			}
			RpcCollection.Instance.TeleportPlayerToBackroomsServerRpc((int)__instance.playerClientId, spawnBody, bodyVelocity, causeOfDeath, deathAnimation);
			return false;
		}

		[HarmonyPatch(typeof(PlayerControllerB), "AllowPlayerDeath")]
		[HarmonyPrefix]
		public static bool PreventPlayerDeath(ref bool __result, PlayerControllerB __instance)
		{
			if (Plugin.backroomsConfig.ShouldPreventDeathTeleport.Value)
			{
				return true;
			}
			if (!_ImmortalPlayers.Contains(__instance.playerSteamId))
			{
				return true;
			}
			__result = false;
			return false;
		}

		[HarmonyPatch(typeof(NoisemakerProp), "ItemActivate")]
		[HarmonyPrefix]
		public static void TeleportForAnnoyingPeople(PlayerControllerB ___playerHeldBy)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.backroomsConfig.ShouldTeleportAnnoyingPeople.Value && MeetRequirementsForBackrooms(___playerHeldBy, lethalDamage: false, negativeDamage: false, annoying: true))
			{
				RpcCollection.Instance.TeleportPlayerToBackroomsServerRpc((int)___playerHeldBy.playerClientId, spawnBody: false, default(Vector3), (CauseOfDeath)0, 0, lethalDamage: false, negativeDamage: false, annoying: true);
			}
		}

		[HarmonyPatch(typeof(Backrooms), "TeleportOutOfBackroomsClientRpc")]
		[HarmonyPostfix]
		public static void RestoreVanillaSounds(int client)
		{
			if (client == (int)StartOfRound.Instance.localPlayerController.playerClientId)
			{
				if (Plugin.enableSoundReplace)
				{
					SoundToolsWrapper.RestoreAudioClip("WoodStep1");
					SoundToolsWrapper.RestoreAudioClip("WoodStep2");
					SoundToolsWrapper.RestoreAudioClip("WoodStep3");
					SoundToolsWrapper.RestoreAudioClip("WoodStep4");
				}
				MusicPlayer component = ((Component)StartOfRound.Instance.localPlayerController).GetComponent<MusicPlayer>();
				if (!((Object)(object)component == (Object)null))
				{
					component.Stop();
				}
			}
		}

		[HarmonyPatch(typeof(Backrooms), "TeleportOutOfBackroomsClientRpc")]
		[HarmonyPostfix]
		public static void TeleportToAndReplaceDeadBody(int client, Backrooms ___Instance)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			if (Plugin.backroomsConfig.ShouldTeleportToAndReplaceDeadBody == null)
			{
				return;
			}
			Debug.Assert(Plugin.backroomsConfig.ShouldTeleportToAndReplaceDeadBody != null, "Plugin.BackroomsConfig.ShouldTeleportToAndReplaceDeadBody != null");
			if (!Plugin.backroomsConfig.ShouldTeleportToAndReplaceDeadBody.Value)
			{
				return;
			}
			PlayerControllerB val = StartOfRound.Instance.allPlayerScripts[client];
			DeadBodyInfo deadBody = val.deadBody;
			if (!((Object)(object)deadBody == (Object)null) && !deadBody.deactivated && (deadBody.grabBodyObject.isInShipRoom || !deadBody.grabBodyObject.isInFactory || (int)deadBody.causeOfDeath != 2))
			{
				Vector3 itemFloorPosition = deadBody.grabBodyObject.GetItemFloorPosition(default(Vector3));
				bool isInFactory = deadBody.grabBodyObject.isInFactory;
				bool isInShipRoom = deadBody.grabBodyObject.isInShipRoom;
				bool isInElevator = deadBody.grabBodyObject.isInElevator;
				Vector3 spawnPosition = deadBody.spawnPosition;
				spawnPosition.x += Vector3.down.x * 200f;
				spawnPosition.y += Vector3.down.y * 200f;
				spawnPosition.z += Vector3.down.z * 200f;
				deadBody.SetRagdollPositionSafely(spawnPosition, true);
				if (((NetworkBehaviour)Backrooms.Instance).IsHost || ((NetworkBehaviour)Backrooms.Instance).IsServer)
				{
					val.SyncBodyPositionWithClients();
					((NetworkBehaviour)deadBody.grabBodyObject).NetworkObject.Despawn(true);
				}
				val.deadBody = null;
				val.TeleportPlayer(itemFloorPosition, false, 0f, false, true);
				val.isInsideFactory = isInFactory;
				val.isInHangarShipRoom = isInShipRoom;
				val.isInElevator = isInElevator;
			}
		}

		private static bool CompareMethodInfoAndMethodBase(MethodInfo methodInfo, MethodBase methodBase)
		{
			if (methodInfo == null)
			{
				return false;
			}
			if (methodBase == null)
			{
				return false;
			}
			if (methodInfo.DeclaringType == null)
			{
				return false;
			}
			if (methodBase.DeclaringType == null)
			{
				return false;
			}
			bool flag = methodInfo.Name == methodBase.Name;
			Debug.Assert(methodInfo.DeclaringType.FullName != null, "methodInfo.DeclaringType.FullName != null");
			bool flag2 = methodInfo.DeclaringType.FullName.Equals(methodBase.DeclaringType.FullName);
			return flag && flag2;
		}

		private static bool Unpatch<T>([NotNull] Harmony harmony, [NotNull] string originalMethodName, [NotNull] string backroomsMethodName)
		{
			MethodInfo methodInfo = typeof(T).GetMethods().FirstOrDefault((MethodInfo method) => method.Name.Equals(originalMethodName));
			MethodInfo method2 = typeof(Hook).GetMethod(backroomsMethodName, BindingFlags.Static | BindingFlags.NonPublic);
			foreach (MethodBase allPatchedMethod in Harmony.GetAllPatchedMethods())
			{
				if (!CompareMethodInfoAndMethodBase(methodInfo, allPatchedMethod))
				{
					continue;
				}
				Patches patchInfo = Harmony.GetPatchInfo(allPatchedMethod);
				if (patchInfo == null)
				{
					Plugin.ErrorLog("Failed to retrieve patch information for method: " + allPatchedMethod.Name);
					continue;
				}
				foreach (Patch prefix in patchInfo.Prefixes)
				{
					MethodInfo method3 = prefix.GetMethod((MethodBase)method2);
					if (!CompareMethodInfoAndMethodBase(method2, method3))
					{
						continue;
					}
					harmony.Unpatch((MethodBase)methodInfo, (HarmonyPatchType)1, prefix.owner);
					Plugin.InfoLog("Unpatched " + originalMethodName + " method!");
					return true;
				}
			}
			Plugin.ErrorLog("Target method not found: " + originalMethodName);
			return false;
		}

		private static void DisablePlayerDeath(int secondsFor, PlayerControllerB player)
		{
			_ImmortalPlayers.Add(player.playerSteamId);
			Timer timer = null;
			timer = new Timer(delegate
			{
				_ImmortalPlayers.Remove(player.playerSteamId);
				timer?.Dispose();
			}, null, secondsFor * 1000, -1);
		}

		internal static void SpawnDeadBody(PlayerControllerB player, Vector3 bodyVelocity, CauseOfDeath causeOfDeath, int deathAnimation, EnemyAI enemyAI, bool isServer = true)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected I4, but got Unknown
			string text = $"PositionObject-{player.playerClientId}-{SystemClock.ToUnixTimeMilliseconds(SystemClock.now)}";
			GameObject val = new GameObject(text);
			Transform transform = val.transform;
			transform.position = player.oldPlayerPosition;
			transform.rotation = player.thisPlayerBody.rotation;
			if (isServer)
			{
				GameObject val2 = Object.Instantiate<GameObject>(StartOfRound.Instance.ragdollGrabbableObjectPrefab, player.playersManager.propsContainer);
				val2.GetComponent<NetworkObject>().Spawn(false);
				val2.GetComponent<RagdollGrabbableObject>().bodyID.Value = (int)player.playerClientId;
			}
			player.SpawnDeadBody((int)player.playerClientId, bodyVelocity, (int)causeOfDeath, player, deathAnimation, transform, default(Vector3));
			player.deadBody.canBeGrabbedBackByPlayers = true;
			if (isServer)
			{
				player.SyncBodyPositionWithClients();
			}
			if (!((Object)(object)enemyAI == (Object)null))
			{
				FlowermanAI val3 = (FlowermanAI)(object)((enemyAI is FlowermanAI) ? enemyAI : null);
				if (val3 != null)
				{
					((EnemyAI)val3).inSpecialAnimationWithPlayer = player;
					val3.FinishKillAnimation(true);
				}
			}
		}

		private static void EnemyFixes(EnemyAI enemyAI)
		{
			FlowermanAI val = (FlowermanAI)(object)((enemyAI is FlowermanAI) ? enemyAI : null);
			if (val == null)
			{
				MaskedPlayerEnemy val2 = (MaskedPlayerEnemy)(object)((enemyAI is MaskedPlayerEnemy) ? enemyAI : null);
				if (val2 != null)
				{
					if ((Object)(object)((EnemyAI)val2).inSpecialAnimationWithPlayer == (Object)(object)GameNetworkManager.Instance.localPlayerController)
					{
						HUDManager.Instance.HUDAnimator.SetBool(_BiohazardDamage, false);
						HUDManager.Instance.HideHUD(true);
						HUDManager.Instance.HideHUD(false);
					}
					val2.FinishKillAnimation(false);
					((EnemyAI)val2).inSpecialAnimationWithPlayer = null;
				}
			}
			else
			{
				val.FinishKillAnimation(false);
				((EnemyAI)val).inSpecialAnimation = false;
			}
		}

		private static bool MeetRequirementsForBackrooms(PlayerControllerB player, bool lethalDamage = true, bool negativeDamage = false, bool annoying = false)
		{
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			Plugin.InfoLog("Player exists!");
			if (player.isPlayerDead || !player.AllowPlayerDeath() || ((Component)player).GetComponent<BackroomsHelper>().HasBeenInTheBackrooms)
			{
				return false;
			}
			Plugin.InfoLog("Passed checks!");
			if (negativeDamage && Plugin.backroomsConfig.ShouldPreventNegativeDamageTeleport.Value)
			{
				return false;
			}
			Plugin.InfoLog("Negative damage check passed!");
			Plugin.InfoLog("Prevent Death Teleport: " + Plugin.backroomsConfig.ShouldPreventDeathTeleport.Value);
			Plugin.InfoLog("Prevent Damage Teleport: " + Plugin.backroomsConfig.ShouldPreventDamageTeleport.Value);
			if (!annoying)
			{
				if ((lethalDamage && Plugin.backroomsConfig.ShouldPreventDeathTeleport.Value) || (!lethalDamage && Plugin.backroomsConfig.ShouldPreventDamageTeleport.Value))
				{
					goto IL_0122;
				}
			}
			else if (!Plugin.backroomsConfig.ShouldTeleportAnnoyingPeople.Value)
			{
				goto IL_0122;
			}
			Plugin.InfoLog("Lethal or not and Annoying check passed!");
			EnemyAI inAnimationWithEnemy = player.inAnimationWithEnemy;
			List<string> list = Plugin.backroomsConfig.PreventBackroomsTeleportEnemies.Value.ToLower().Replace(" ", "").Split(",")
				.ToList();
			if ((Object)(object)inAnimationWithEnemy != (Object)null && list.Contains(inAnimationWithEnemy.enemyType.enemyName.ToLower()))
			{
				return false;
			}
			Plugin.InfoLog("AI check passed!");
			int value = (annoying ? Plugin.backroomsConfig.TeleportAnnoyingPeopleChance : (lethalDamage ? Plugin.backroomsConfig.TeleportLethalDamageChance : Plugin.backroomsConfig.TeleportNonLethalDamageChance)).Value;
			Plugin.InfoLog($"Teleport chance: {value}!");
			int num = Random.Range(1, 100);
			Plugin.InfoLog($"Rolled chance: {num}!");
			if (num > value)
			{
				return false;
			}
			Plugin.InfoLog("Chance check passed!");
			return true;
			IL_0122:
			return false;
		}

		internal static void TeleportPlayerToBackrooms(PlayerControllerB player, bool spawnBody = false, Vector3 bodyVelocity = default(Vector3), CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool lethalDamage = true, bool annoying = false)
		{
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			Plugin.InfoLog("Teleport To Backrooms method!");
			EnemyAI inAnimationWithEnemy = player.inAnimationWithEnemy;
			int enemyId = (((Object)(object)inAnimationWithEnemy == (Object)null) ? (-1) : inAnimationWithEnemy.thisEnemyIndex);
			EnemyFixes(inAnimationWithEnemy);
			Plugin.InfoLog("Enemy Fixes passed!");
			if (ShouldDropItems(lethalDamage, annoying))
			{
				player.DropAllHeldItemsAndSync();
			}
			DisablePlayerDeath(2, player);
			Plugin.InfoLog("Sending player to backrooms!");
			Backrooms.Instance.TeleportToBackroomsServerRpc((int)player.playerClientId);
			if (Plugin.enableSoundReplace && player.playerClientId == StartOfRound.Instance.localPlayerController.playerClientId)
			{
				for (int i = 1; i <= 4; i++)
				{
					int num = i - 1;
					AudioClip newClip = Plugin.CarpetSounds[num];
					SoundToolsWrapper.ReplaceAudioClip($"WoodStep{i}", newClip);
				}
				((Component)player).gameObject.AddComponent<MusicPlayer>();
			}
			if (Plugin.backroomsConfig.ShouldSpawnDeadBody != null)
			{
				Debug.Assert(Plugin.backroomsConfig.ShouldSpawnDeadBody != null, "Plugin.BackroomsConfig.ShouldSpawnDeadBody != null");
				if (Plugin.backroomsConfig.ShouldSpawnDeadBody.Value && spawnBody)
				{
					Plugin.InfoLog("Spawning body!");
					RpcCollection.Instance.SpawnDeadBodyServerRpc((int)player.playerClientId, bodyVelocity, causeOfDeath, deathAnimation, enemyId);
				}
			}
		}

		private static bool ShouldDropItems(bool lethalDamage, bool annoying)
		{
			int num;
			switch (Plugin.backroomsConfig.DropHeldItemsMode.Value)
			{
			case DropHeldItemsMode.DropAllOnAnnoyingAndDeath:
				num = 0;
				goto IL_003a;
			case DropHeldItemsMode.DropAllOnDeath:
				num = 1;
				goto IL_003a;
			case DropHeldItemsMode.DropAllOnAnnoying:
				if (!annoying)
				{
					break;
				}
				goto case DropHeldItemsMode.DropAll;
			case DropHeldItemsMode.DropAll:
				{
					return true;
				}
				IL_003a:
				if (!lethalDamage)
				{
					if (num == 0)
					{
						goto case DropHeldItemsMode.DropAllOnAnnoying;
					}
					if (num == 1)
					{
						break;
					}
				}
				goto case DropHeldItemsMode.DropAll;
			}
			return false;
		}
	}
	[BepInPlugin("TestAccount666.RealBackroomsPatch", "RealBackroomsPatch", "1.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public const int CARPET_SOUNDS_SIZE = 4;

		private static Plugin _instance;

		public static BackroomsConfig backroomsConfig;

		public static readonly AudioClip[] CarpetSounds = (AudioClip[])(object)new AudioClip[4];

		public static bool enableSoundReplace;

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

		private void Awake()
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			_instance = this;
			WarningLog("This Mod is my very first Mod and is still work in progress.");
			backroomsConfig = new BackroomsConfig("TestAccount666.RealBackroomsPatch", ((BaseUnityPlugin)this).Config);
			Harmony val = new Harmony("TestAccount666.RealBackroomsPatch");
			InfoLog("Creating patches!");
			val.PatchAll(typeof(Patches));
			val.PatchAll(typeof(LightFlickerEffect));
			val.PatchAll(typeof(RpcCollectionLoader));
			val.PatchAll(typeof(SmilerPatch));
			if (DependencyChecker.IsGroanTubeModInstalled())
			{
				val.PatchAll(typeof(GroanTubePatch));
			}
			enableSoundReplace = DependencyChecker.IsSoundToolsModInstalled();
			InfoLog("Unpatching Backrooms Mod!");
			Patches.UnpatchDamagePlayerMethod(val);
			Patches.UnpatchKillPlayerMethod(val);
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			Type[] array = types;
			foreach (Type type in array)
			{
				MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic);
				MethodInfo[] array2 = methods;
				foreach (MethodInfo methodInfo in array2)
				{
					object[] customAttributes = methodInfo.GetCustomAttributes(typeof(RuntimeInitializeOnLoadMethodAttribute), inherit: false);
					if (customAttributes.Length != 0)
					{
						methodInfo.Invoke(null, null);
					}
				}
			}
			((MonoBehaviour)this).StartCoroutine(LoadAudioClips());
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin RealBackroomsPatch is loaded!");
		}

		internal static void DebugLog(string msg)
		{
			((BaseUnityPlugin)_instance).Logger.LogDebug((object)msg);
		}

		internal static void InfoLog(string msg)
		{
			((BaseUnityPlugin)_instance).Logger.LogInfo((object)msg);
		}

		internal static void WarningLog(string msg)
		{
			((BaseUnityPlugin)_instance).Logger.LogWarning((object)msg);
		}

		internal static void ErrorLog(string msg)
		{
			((BaseUnityPlugin)_instance).Logger.LogError((object)msg);
		}

		private static IEnumerator LoadAudioClips()
		{
			string assemblyDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			InfoLog("Loading Carpet Step Sounds...");
			Debug.Assert(assemblyDirectory != null, "assemblyDirectory != null");
			string audioPath = Path.Combine(assemblyDirectory, "sounds");
			audioPath = (Directory.Exists(audioPath) ? audioPath : Path.Combine(assemblyDirectory));
			string carpetAudioPath2 = Path.Combine(audioPath, "CarpetSound");
			carpetAudioPath2 = (Directory.Exists(carpetAudioPath2) ? carpetAudioPath2 : Path.Combine(assemblyDirectory));
			for (int index = 1; index <= 4; index++)
			{
				int sound = index - 1;
				AudioClip carpetAudioClip = LoadAudioClipFromFile(new Uri(Path.Combine(carpetAudioPath2, $"CarpetStep{index}.wav")), $"CarpetStep{index}", (AudioType)20);
				CarpetSounds[sound] = carpetAudioClip;
				InfoLog("Loaded clip '" + ((Object)carpetAudioClip).name + "'!");
			}
			InfoLog("Loading Music...");
			string musicAudioPath2 = Path.Combine(audioPath, "Music");
			musicAudioPath2 = (Directory.Exists(musicAudioPath2) ? musicAudioPath2 : Path.Combine(assemblyDirectory));
			foreach (string file in Directory.EnumerateFiles(musicAudioPath2))
			{
				string fileName = Path.GetFileName(file);
				if (fileName.ToLower().EndsWith(".ogg") && fileName.ToLower().StartsWith("music"))
				{
					Uri filePath = new Uri(file);
					string text = fileName;
					AudioClip musicAudioClip = LoadAudioClipFromFile(filePath, text.Substring(0, text.Length - 4), (AudioType)14);
					MusicSounds.Add(musicAudioClip);
					InfoLog("Loaded clip '" + ((Object)musicAudioClip).name + "'!");
				}
			}
			yield break;
		}

		private static AudioClip LoadAudioClipFromFile(Uri filePath, string name, AudioType audioType = 20)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			UnityWebRequest audioClip = UnityWebRequestMultimedia.GetAudioClip(filePath, audioType);
			try
			{
				UnityWebRequestAsyncOperation val = audioClip.SendWebRequest();
				while (!((AsyncOperation)val).isDone)
				{
					Thread.Sleep(100);
				}
				if ((int)audioClip.result != 1)
				{
					ErrorLog("Failed to load AudioClip: " + audioClip.error);
					return null;
				}
				AudioClip content = DownloadHandlerAudioClip.GetContent(audioClip);
				((Object)content).name = name;
				return content;
			}
			finally
			{
				((IDisposable)audioClip)?.Dispose();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "TestAccount666.RealBackroomsPatch";

		public const string PLUGIN_NAME = "RealBackroomsPatch";

		public const string PLUGIN_VERSION = "1.1.0";
	}
	public class RpcCollection : NetworkBehaviour
	{
		public static RpcCollection Instance { get; private set; }

		public override void OnNetworkSpawn()
		{
			Plugin.InfoLog("RpcCollection network spawned!");
			if ((Object)(object)NetworkManager.Singleton == (Object)null)
			{
				Plugin.ErrorLog("NetworkManager.Singleton couldn't be found?!");
				return;
			}
			if ((NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer) && (Object)(object)Instance != (Object)null && (Object)(object)((Component)Instance).gameObject != (Object)null)
			{
				((Component)Instance).gameObject.GetComponent<NetworkObject>().Despawn(true);
			}
			Instance = this;
		}

		[ClientRpc]
		public void SpawnDeadBodyClientRpc(int playerId, Vector3 bodyVelocity, CauseOfDeath causeOfDeath, int deathAnimation, int enemyId)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			Plugin.InfoLog("Spawn dead body ClientRpc!");
			PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerId];
			EnemyAI enemyAI = ((enemyId != -1) ? RoundManager.Instance.SpawnedEnemies[enemyId] : null);
			Patches.SpawnDeadBody(player, bodyVelocity, causeOfDeath, deathAnimation, enemyAI, ((NetworkBehaviour)this).IsServer);
		}

		[ServerRpc(RequireOwnership = false)]
		public void SpawnDeadBodyServerRpc(int playerId, Vector3 bodyVelocity, CauseOfDeath causeOfDeath, int deathAnimation, int enemyId)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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)
			Plugin.InfoLog("Spawn body ServerRpc!");
			PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerId];
			EnemyAI enemyAI = ((enemyId != -1) ? RoundManager.Instance.SpawnedEnemies[enemyId] : null);
			if (((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				Plugin.InfoLog("Server spawning DeadBody!");
				Patches.SpawnDeadBody(player, bodyVelocity, causeOfDeath, deathAnimation, enemyAI, ((NetworkBehaviour)this).IsServer);
			}
			else
			{
				SpawnDeadBodyClientRpc(playerId, bodyVelocity, causeOfDeath, deathAnimation, enemyId);
			}
		}

		[ClientRpc]
		public void TeleportPlayerToBackroomsClientRpc(int playerId, bool spawnBody = false, Vector3 bodyVelocity = default(Vector3), CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool lethalDamage = true, bool negativeDamage = false, bool annoying = false)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			Plugin.InfoLog("Teleport Player ClientRcp!");
			PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerId];
			Patches.TeleportPlayerToBackrooms(player, spawnBody, bodyVelocity, causeOfDeath, deathAnimation, lethalDamage, annoying);
		}

		[ServerRpc(RequireOwnership = false)]
		public void TeleportPlayerToBackroomsServerRpc(int playerId, bool spawnBody = false, Vector3 bodyVelocity = default(Vector3), CauseOfDeath causeOfDeath = 0, int deathAnimation = 0, bool lethalDamage = true, bool negativeDamage = false, bool annoying = false)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			Plugin.InfoLog("Teleport Player ServerRcp!");
			PlayerControllerB player = StartOfRound.Instance.allPlayerScripts[playerId];
			if (((NetworkBehaviour)this).IsServer && !((NetworkBehaviour)this).IsHost)
			{
				Plugin.InfoLog("Server but not host Teleport!");
				Patches.TeleportPlayerToBackrooms(player, spawnBody, bodyVelocity, causeOfDeath, deathAnimation, lethalDamage, annoying);
			}
			TeleportPlayerToBackroomsClientRpc(playerId, spawnBody, bodyVelocity, causeOfDeath, deathAnimation, lethalDamage, negativeDamage, annoying);
		}
	}
	[HarmonyPatch]
	public class RpcCollectionLoader
	{
		private static GameObject _networkPrefab;

		private static int _networkPrefabInstanceId = -1;

		private static int _networkHandlerHostInstanceId = -1;

		private static NetworkObject _networkHandlerHost;

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnDestroy")]
		public static void AfterDestroy()
		{
			if ((Object)(object)_networkPrefab != (Object)null)
			{
				RpcCollection component = _networkPrefab.GetComponent<RpcCollection>();
				if ((Object)(object)component != (Object)null)
				{
					Object.Destroy((Object)(object)component);
				}
				Object.Destroy((Object)(object)_networkPrefab);
				_networkPrefab = null;
				_networkPrefabInstanceId = -1;
			}
			if (!((Object)(object)_networkHandlerHost == (Object)null))
			{
				Object.Destroy((Object)(object)_networkHandlerHost);
				_networkHandlerHost = null;
				_networkPrefabInstanceId = -1;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		public static void SpawnNetworkHandler1()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			_networkPrefab = NetworkPrefabs.CreateNetworkPrefab("RpcCollectionHandler");
			_networkPrefab.AddComponent<RpcCollection>();
			_networkPrefabInstanceId = ((Object)_networkPrefab).GetInstanceID();
			Object.DontDestroyOnLoad((Object)(object)_networkPrefab);
			if ((NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer) && (!((Object)(object)_networkHandlerHost != (Object)null) || !(Object.FindObjectFromInstanceID(_networkHandlerHostInstanceId) != (Object)null)))
			{
				_networkHandlerHost = Object.Instantiate<GameObject>(_networkPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>();
				_networkHandlerHost.Spawn(false);
				Object.DontDestroyOnLoad((Object)(object)_networkHandlerHost);
				_networkHandlerHostInstanceId = ((Object)_networkHandlerHost).GetInstanceID();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(StartOfRound), "OnEnable")]
		public static void SpawnNetworkHandler2()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_networkPrefab == (Object)null || Object.FindObjectFromInstanceID(_networkPrefabInstanceId) == (Object)null)
			{
				_networkPrefab = NetworkPrefabs.CreateNetworkPrefab("RpcCollectionHandler");
				_networkPrefab.AddComponent<RpcCollection>();
				_networkPrefabInstanceId = ((Object)_networkPrefab).GetInstanceID();
				Object.DontDestroyOnLoad((Object)(object)_networkPrefab);
			}
			if ((NetworkManager.Singleton.IsHost || NetworkManager.Singleton.IsServer) && (!((Object)(object)_networkHandlerHost != (Object)null) || !(Object.FindObjectFromInstanceID(_networkHandlerHostInstanceId) != (Object)null)))
			{
				_networkHandlerHost = Object.Instantiate<GameObject>(_networkPrefab, Vector3.zero, Quaternion.identity).GetComponent<NetworkObject>();
				_networkHandlerHost.Spawn(false);
				Object.DontDestroyOnLoad((Object)(object)_networkHandlerHost);
				_networkHandlerHostInstanceId = ((Object)_networkHandlerHost).GetInstanceID();
			}
		}
	}
	[HarmonyPatch(typeof(Smiler))]
	public static class SmilerPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void FixSmiler(Smiler __instance)
		{
			GameObject gameObject = ((Component)((Component)__instance).gameObject.transform.Find("KillBox")).gameObject;
			KillBox component = gameObject.GetComponent<KillBox>();
			Object.Destroy((Object)(object)component);
			gameObject.AddComponent<FixedKillBox>();
		}
	}
	internal static class SoundToolsWrapper
	{
		public static void RestoreAudioClip(string name)
		{
			SoundTool.RestoreAudioClip(name);
		}

		public static void ReplaceAudioClip(string originalName, AudioClip newClip)
		{
			SoundTool.ReplaceAudioClip(originalName, newClip);
		}
	}
	public static class StartOfRoundPatch
	{
		public static void SyncBackroomsConfig()
		{
			if (Plugin.backroomsConfig == null)
			{
				Plugin.ErrorLog("Config not found, please report this!");
			}
			else if (((NetworkBehaviour)RoundManager.Instance).IsHost)
			{
				Plugin.InfoLog("Skipping sync request, since we're the host!");
			}
		}
	}
	public static class UnixTime
	{
		public static long GetCurrentTime()
		{
			return (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
		}
	}
}